Migration Guide for Chemaxon Java Libraries 26.x¶

Introduction
Module Changes
- Maven Artifacts
- Top-Level Modules
Java API Changes

Introduction¶

With the release of version 26, the Java Libraries of Chemaxon are taking a significant step toward full Java modularization. This document describes the changes introduced, their impact on existing integrations, and the recommended migration path.

Note that these changes only apply to Java API usage, applications and hosted services are not affected.

Why Now?¶

Version 26 marks the first Chemaxon release built on Java 21. This upgrade was already a necessary breaking change, as Oracle's public support for Java 17 (the foundation of our previous release) ended in September 2025. Given that a migration effort was already required, we took the opportunity to simultaneously prepare our libraries for the Java Module System (also known as Project Jigsaw), a technology that has been steadily gaining importance in the Java ecosystem.

This decision reflects a broader trend in Java's evolution: while the classpath is not being officially deprecated, new platform capabilities (such as native memory access) are increasingly available only within the module system. Relying on workarounds outside of it requires disabling platform integrity checks globally, which introduces security risks we are not willing to pass on to our customers.

For those who cannot migrate immediately, Silicon LTS (25.4.x) remains supported for at least two more years under our updated release policy.

What Has Changed — and What Has Not¶

In order to eliminate so-called split packages (Java Module System does not allow a package to exist across multiple JARs) and to reflect the evolution of our product portfolio, we have relocated a number of classes between packages. Furthermore, a few rarely used classes have been discontinued. However, public API method signatures have not been changed to ensure straightforward and safe migration. In most cases, you just need to apply the changes in class and package names, which can be performed easily with the provided migration script (see details below).

Split packages in Java

The split package problem refers to a constraint of the Java Module System: two separate JAR files are not permitted to contain classes belonging to the same package. Prior to modularization, this was a common and unproblematic pattern; under the module system, it is strictly forbidden. Resolving it requires consolidating or redistributing classes so that each package resides in exactly one module.

One important exception to note: pre-compiled binaries that previously required only a JAR swap may no longer be compatible and will need to be recompiled. That said, the most widely used APIs remain in their original locations, which means that, for example, existing Standardizer plugins are likely to continue working without any modifications.

Following sections of this document provide detailed tables of all renamed classes and discontinued classes.

What to Expect in Version 27¶

In the next annual release, our JARs will include module-info.class descriptors, which will formally encapsulate non-public APIs. No further structural changes are planned beyond this. Customers who continue to use our JARs via the classpath will not be affected by this addition — the benefits of the module system are available to those who opt in, and we have no plans to make modular usage mandatory.

How to Migrate¶

The migration process consists of the following steps:

update your dependencies to version 26 (not only a version change, module names have also been changed);
resolve any compilation errors using our migration script (which tracks relocated classes and applies the correct replacements);
and address any remaining issues manually with reference to the migration tables below.

Detailed instructions for each step follow in the subsequent sections.

We Are Here to Help¶

We understand that migration efforts can be disruptive, and we want to make this transition as smooth as possible. If you have questions or run into difficulties, our support team is ready to assist. For more complex integration scenarios, our Professional Services team is also available to provide hands-on guidance.

We welcome all feedback through our standard support channels.

Module Changes¶

Maven Artifacts¶

Starting from version 26, the Maven identifiers of Chemaxon Java libraries have also been revised. For example, a "chemaxon-" prefix has been added to each artifact ID to avoid name collisions with commonly used third-party library names. That is, in addition to changing the version number, you will also need to update the artifact IDs in your build configuration. Please refer to the table below for the new top-level modules.

Top-Level Modules¶

Chemaxon Java libraries are organized into several modules, which are distributed as separate JAR files. The names and actual hierarchy of these modules are subject to change over time, so we recommend that you do not depend on lower-level modules directly, but on top-level "bundle" modules instead. All required dependencies will be downloaded transitively.

From version 26, we recommend one of the following three top-level modules to be used directly.

Module	Feature set
`chemaxon-chemistry`	The comprehensive chemistry toolkit of Chemaxon without GUI components and tools for database handling and document processing.
`chemaxon-marvin-classic`	Marvin Desktop Suite, which includes the chemistry toolkit, Swing GUI components related to MarvinSketch and MarvinView, and tools for document processing. See API reference documentation here.
`chemaxon-jchem`	JChem Suite, the full Java toolkit of Chemaxon, which includes Marvin Desktop Suite and database handling tools. See API reference documentation here.

Java API Changes¶

Goals and Concepts¶

As described in the introduction, a number of classes have been relocated, renamed, or discontinued in order to prepare our libraries for the Java Module System and to reflect the evolution of our product portfolio and the intention to clarify and standardize our public Java API.

These API changes implement the following goals and concepts.

Modularity: classes are reorganized into packages and modules that avoid split packages and better reflect the functionality and connections of the API.
Consistency: com.chemaxon.* packages are renamed to chemaxon.* to align with the naming convention of our most widely used classes.
Clarity: some classes are renamed to better reflect their purpose and usage, making the API more intuitive for new users.
Streamlining: a few rarely used classes not suitable for external use are discontinued to reduce confusion and maintenance.
API separation: packages containing classes not intended for public use are renamed to include internal in their names. These classes should not be used directly in your code (even if they are technically public) as they are subject to change without notice in future releases.
No method changes: public API method signatures remain unchanged, ensuring straightforward and safe migration with minimal impact on existing integrations.

Migration Script¶

To facilitate the migration process, we have developed a simple script that can be run in a specified folder containing Java source files. This script can automatically apply the majority of the necessary changes to the class names and package names based on the tables provided in this document.

The migration script is available in both Bash and PowerShell versions.

chemaxon_java_migration_script_26.sh (Bash script for Linux and macOS)
ChemaxonJavaMigrationScript26.ps1 (PowerShell script for Windows)

How to use the script

Note that the migration script performs in-place modifications in the specified folder, but it creates a backup copy of the original files before applying any changes. For more information, execute the script without parameters.

Moved or Renamed Classes¶

In most cases, it is sufficient to apply the migration script to update your codebase. For full reference, however, the table below lists all public API classes that have been moved or renamed in version 26.

Old name (version 25)	New name (from version 26)
`chemaxon.calculations.ElementalAnalyser`	`chemaxon.core.calculations.ElementalAnalyzer`
`chemaxon.calculations.Ring`	`chemaxon.core.calculations.Ring`
`chemaxon.calculations.TopologyAnalyser`	`chemaxon.core.calculations.TopologyAnalyzer`
`chemaxon.calculations.cip.CIPStereoCalculator`	`chemaxon.core.calculations.stereo.CIPStereoCalculator`
`chemaxon.calculations.clean.AtomChangeEventListener`	`chemaxon.core.calculations.clean.Cleaner.AtomChangeEventListener`
`chemaxon.calculations.clean.Cleaner`	`chemaxon.core.calculations.clean.Cleaner`
`chemaxon.calculations.hydrogenize.Hydrogenize`	`chemaxon.core.calculations.Hydrogenizer`
`chemaxon.calculations.nmr.Multiplet`	`chemaxon.calculations.nmr.NMRMultiplet`
`chemaxon.calculations.nmr.NMRCoefficient.ErrorClassification`	`chemaxon.calculations.nmr.NMRErrorClassification`
`chemaxon.calculations.nmr.Shift`	`chemaxon.calculations.nmr.NMRShift`
`chemaxon.calculations.nmr.io.NMRExporter`	`chemaxon.calculations.nmr.NMRExporter`
`chemaxon.calculations.pka.PKaTrainingResult`	`chemaxon.calculations.PkaTrainingResult`
`chemaxon.calculations.pka.PKaTrainingResult.PKaType`	`chemaxon.calculations.PkaTrainingResult.PkaType`
`chemaxon.calculations.stereo.Stereochemistry`	`chemaxon.core.calculations.stereo.Stereochemistry`
`chemaxon.calculator.Calculator`	`chemaxon.calculations.api.Calculator`
`chemaxon.calculator.CalculatorBuilder`	`chemaxon.calculations.api.CalculatorBuilder`
`chemaxon.calculator.CalculatorError`	`chemaxon.calculations.api.CalculatorError`
`chemaxon.calculator.CalculatorFormatter`	`chemaxon.calculations.api.CalculatorFormatter`
`chemaxon.calculator.CalculatorInputChecker`	`chemaxon.calculations.api.CalculatorInputChecker`
`chemaxon.calculator.CalculatorLogger`	`chemaxon.calculations.api.CalculatorLogger`
`chemaxon.calculator.CalculatorTag`	`chemaxon.calculations.api.CalculatorTag`
`chemaxon.calculator.HeavyAtomLimitChecker`	`chemaxon.calculations.api.HeavyAtomLimitChecker`
`chemaxon.calculator.ProgressableCalculator`	`chemaxon.calculations.api.ProgressableCalculator`
`chemaxon.calculator.TaggedCalculator`	`chemaxon.calculations.api.TaggedCalculator`
`chemaxon.calculator.TaggedCalculatorInputChecker`	`chemaxon.calculations.api.TaggedCalculatorInputChecker`
`chemaxon.checkers.DoubleBondStereoErrorChecker`	`chemaxon.checkers.DoubleBondStereoErrorChecker`
`chemaxon.checkers.Persistent`	`chemaxon.checkers.PersistentProperty`
`chemaxon.checkers.logger.StructureCheckerLogger`	`chemaxon.structurechecker.StructureCheckerMonitor`
`chemaxon.checkers.result.ConvertConstants`	`chemaxon.checkers.result.ConversionConstants`
`chemaxon.checkers.runner.AdvancedCheckerRunner`	`chemaxon.structurechecker.AdvancedCheckerRunner`
`chemaxon.checkers.runner.BasicCheckerRunner`	`chemaxon.structurechecker.BasicCheckerRunner`
`chemaxon.checkers.runner.CheckerRunner`	`chemaxon.structurechecker.CheckerRunner`
`chemaxon.checkers.runner.configuration.reader.ActionStringBasedConfigurationReader`	`chemaxon.structurechecker.configuration.StructureCheckerActionStringReader`
`chemaxon.checkers.runner.configuration.reader.ConfigurationReader`	`chemaxon.structurechecker.configuration.StructureCheckerConfigurationReader`
`chemaxon.checkers.runner.configuration.reader.XMLBasedConfigurationReader`	`chemaxon.structurechecker.configuration.StructureCheckerConfigurationXmlReader`
`chemaxon.checkers.runner.configuration.writer.ActionStringBasedConfigurationWriter`	`chemaxon.structurechecker.configuration.StructureCheckerActionStringWriter`
`chemaxon.checkers.runner.configuration.writer.ConfigurationWriter`	`chemaxon.structurechecker.configuration.StructureCheckerConfigurationWriter`
`chemaxon.checkers.runner.configuration.writer.XMLBasedConfigurationWriter`	`chemaxon.structurechecker.configuration.StructureCheckerConfigurationXmlWriter`
`chemaxon.checkers.util.AtomLabels`	`chemaxon.checkers.AtomLabels`
`chemaxon.checkers.util.DataExclusionList`	`chemaxon.checkers.AttachedDataChecker.DataExclusionList`
`chemaxon.clustering.Common`	`chemaxon.clustering.AbstractClusteringMethod`
`chemaxon.clustering.Compare`	`chemaxon.clustering.LibraryComparator`
`chemaxon.clustering.JarvisPatrick`	`chemaxon.clustering.JarvisPatrickClustering`
`chemaxon.clustering.NearestNeighbors`	`chemaxon.clustering.NearestNeighborsClustering`
`chemaxon.clustering.Ward`	`chemaxon.clustering.WardClustering`
`chemaxon.clustering.libmcs.adapter.LegacyLibraryMcsAdapter`	`chemaxon.clustering.libmcs.LegacyLibraryMcsAdapter`
`chemaxon.clustering.libmcs.adapter.LegacyLibraryMcsParameters`	`chemaxon.clustering.libmcs.LegacyLibraryMcsParameters`
`chemaxon.common.util.MProgressMonitor`	`chemaxon.core.util.MProgressMonitor`
`chemaxon.core.ChemConst`	`chemaxon.struc.PeriodicTable` (*)
`chemaxon.core.calculations.valencecheck.ValenceCheckOptions`	`chemaxon.struc.ValenceCheckOptions`
`chemaxon.core.util.BondTable`	`chemaxon.struc.BondTable`
`chemaxon.descriptors.GenerateMD`	`chemaxon.jchem.descriptors.GenerateMD`
`chemaxon.descriptors.MDArrayReader`	`chemaxon.jchem.descriptors.MDArrayReader`
`chemaxon.descriptors.MDDBReader`	`chemaxon.jchem.descriptors.MDDBReader`
`chemaxon.descriptors.MDDBWriter`	`chemaxon.jchem.descriptors.MDDBWriter`
`chemaxon.descriptors.MDFileReader`	`chemaxon.jchem.descriptors.MDFileReader`
`chemaxon.descriptors.MDFileWriter`	`chemaxon.jchem.descriptors.MDFileWriter`
`chemaxon.descriptors.MDHitEvaluator`	`chemaxon.jchem.descriptors.MDHitEvaluator`
`chemaxon.descriptors.MDHypothesisCreator`	`chemaxon.jchem.descriptors.MDHypothesisCreator`
`chemaxon.descriptors.MDHypothesisGenerator`	`chemaxon.jchem.descriptors.MDHypothesisGenerator`
`chemaxon.descriptors.MDMetricOptimizer`	`chemaxon.jchem.descriptors.MDMetricOptimizer`
`chemaxon.descriptors.MDReader`	`chemaxon.jchem.descriptors.MDReader`
`chemaxon.descriptors.MDReaderException`	`chemaxon.jchem.descriptors.MDReaderException`
`chemaxon.descriptors.MDSet`	`chemaxon.jchem.descriptors.MDSet`
`chemaxon.descriptors.MDSetParameters`	`chemaxon.jchem.descriptors.MDSetParameters`
`chemaxon.descriptors.MDSimilarity`	`chemaxon.jchem.descriptors.MDSimilarity`
`chemaxon.descriptors.MDSimilarityResultWriter`	`chemaxon.jchem.descriptors.MDSimilarityResultWriter`
`chemaxon.descriptors.MDWriter`	`chemaxon.jchem.descriptors.MDWriter`
`chemaxon.descriptors.MDWriterException`	`chemaxon.jchem.descriptors.MDWriterException`
`chemaxon.formats.MolConverter`	`chemaxon.formats.converter.MolConverter`
`chemaxon.formats.documents.jchemexcel.ILocation`	`chemaxon.office.jchemexcel.ILocation`
`chemaxon.formats.documents.jchemexcel.IMoleculeMap`	`chemaxon.office.jchemexcel.IMoleculeMap`
`chemaxon.formats.documents.jchemexcel.IWorkbookReader`	`chemaxon.office.jchemexcel.IWorkbookReader`
`chemaxon.formats.documents.jchemexcel.JChemExcelAPI`	`chemaxon.office.jchemexcel.JChemExcelAPI`
`chemaxon.formats.documents.jchemexcel.StructureToJC4XL`	`chemaxon.office.jchemexcel.StructureToJC4XL`
`chemaxon.formats.documents.jchemexcel.WorkbookHandlerFactory`	`chemaxon.office.jchemexcel.WorkbookHandlerFactory`
`chemaxon.formats.documents.jchemoffice.BatchProcessingException`	`chemaxon.office.jchemoffice.BatchProcessingException`
`chemaxon.formats.documents.jchemoffice.CardLayoutArrangement`	`chemaxon.office.jchemoffice.CardLayoutArrangement`
`chemaxon.formats.documents.jchemoffice.CodeGenerator`	`chemaxon.office.jchemoffice.CodeGenerator`
`chemaxon.formats.documents.jchemoffice.ConditionalRuleOperators`	`chemaxon.office.jchemoffice.ConditionalRuleOperators`
`chemaxon.formats.documents.jchemoffice.ConditionRule`	`chemaxon.office.jchemoffice.ConditionRule`
`chemaxon.formats.documents.jchemoffice.ConversionOptions`	`chemaxon.office.jchemoffice.ConversionOptions`
`chemaxon.formats.documents.jchemoffice.DataType`	`chemaxon.office.jchemoffice.DataType`
`chemaxon.formats.documents.jchemoffice.DocumentHandlerFactory`	`chemaxon.office.jchemoffice.DocumentHandlerFactory`
`chemaxon.formats.documents.jchemoffice.DocumentType`	`chemaxon.office.jchemoffice.DocumentType`
`chemaxon.formats.documents.jchemoffice.DocumentUtility`	`chemaxon.office.jchemoffice.DocumentUtility`
`chemaxon.formats.documents.jchemoffice.FileNameGenerationMode`	`chemaxon.office.jchemoffice.FileNameGenerationMode`
`chemaxon.formats.documents.jchemoffice.FontAlignment`	`chemaxon.office.jchemoffice.FontAlignment`
`chemaxon.formats.documents.jchemoffice.FontStyle`	`chemaxon.office.jchemoffice.FontStyle`
`chemaxon.formats.documents.jchemoffice.GenericOptions`	`chemaxon.office.jchemoffice.GenericOptions`
`chemaxon.formats.documents.jchemoffice.ICardLayout`	`chemaxon.office.jchemoffice.ICardLayout`
`chemaxon.formats.documents.jchemoffice.ICellData`	`chemaxon.office.jchemoffice.ICellData`
`chemaxon.formats.documents.jchemoffice.ICellFormat`	`chemaxon.office.jchemoffice.ICellFormat`
`chemaxon.formats.documents.jchemoffice.ICodeGenerator`	`chemaxon.office.jchemoffice.ICodeGenerator`
`chemaxon.formats.documents.jchemoffice.IConversionOptions`	`chemaxon.office.jchemoffice.IConversionOptions`
`chemaxon.formats.documents.jchemoffice.IDocumentConverter`	`chemaxon.office.jchemoffice.IDocumentConverter`
`chemaxon.formats.documents.jchemoffice.IDocumentReader`	`chemaxon.office.jchemoffice.IDocumentReader`
`chemaxon.formats.documents.jchemoffice.IDocumentTemplateWriter`	`chemaxon.office.jchemoffice.IDocumentTemplateWriter`
`chemaxon.formats.documents.jchemoffice.IDocumentWriter`	`chemaxon.office.jchemoffice.IDocumentWriter`
`chemaxon.formats.documents.jchemoffice.IGenericOptions`	`chemaxon.office.jchemoffice.IGenericOptions`
`chemaxon.formats.documents.jchemoffice.ImageGenerationType`	`chemaxon.office.jchemoffice.ImageGenerationType`
`chemaxon.formats.documents.jchemoffice.IMoleculeData`	`chemaxon.office.jchemoffice.IMoleculeData`
`chemaxon.formats.documents.jchemoffice.IMoleculeRenderer`	`chemaxon.office.jchemoffice.IMoleculeRenderer`
`chemaxon.formats.documents.jchemoffice.IPropertyTableCellFormats`	`chemaxon.office.jchemoffice.IPropertyTableCellFormats`
`chemaxon.formats.documents.jchemoffice.ISettings`	`chemaxon.office.jchemoffice.ISettings`
`chemaxon.formats.documents.jchemoffice.ITableCell`	`chemaxon.office.jchemoffice.ITableCell`
`chemaxon.formats.documents.jchemoffice.ITableModel`	`chemaxon.office.jchemoffice.ITableModel`
`chemaxon.formats.documents.jchemoffice.ITemplateWriterOptions`	`chemaxon.office.jchemoffice.ITemplateWriterOptions`
`chemaxon.formats.documents.jchemoffice.Location`	`chemaxon.office.jchemoffice.Location`
`chemaxon.formats.documents.jchemoffice.MoleculeData`	`chemaxon.office.jchemoffice.MoleculeData`
`chemaxon.formats.documents.jchemoffice.MoleculeMap`	`chemaxon.office.jchemoffice.MoleculeMap`
`chemaxon.formats.documents.jchemoffice.MoleculeRenderContainer`	`chemaxon.office.jchemoffice.MoleculeRenderContainer`
`chemaxon.formats.documents.jchemoffice.PropertyColoring`	`chemaxon.office.jchemoffice.PropertyColoring`
`chemaxon.formats.documents.jchemoffice.PropertyTablePosition`	`chemaxon.office.jchemoffice.PropertyTablePosition`
`chemaxon.formats.documents.jchemoffice.ReportSettings`	`chemaxon.office.jchemoffice.ReportSettings`
`chemaxon.formats.documents.jchemoffice.SupportedOLETypes`	`chemaxon.office.jchemoffice.SupportedOLETypes`
`chemaxon.formats.documents.jchemoffice.TemplateWriterOptions`	`chemaxon.office.jchemoffice.TemplateWriterOptions`
`chemaxon.formats.recognizer.Recognizer`	`chemaxon.formats.Recognizer`
`chemaxon.jchem.db.DatabaseConstants`	`chemaxon.jchem.db.constants.DatabaseConstants`
`chemaxon.jchem.db.DatabaseSearchException`	`chemaxon.jchem.db.exceptions.JChemSearchException`
`chemaxon.jchem.db.Exporter`	`chemaxon.jchem.db.TableExporter`
`chemaxon.jchem.db.Importer`	`chemaxon.jchem.db.TableImporter`
`chemaxon.jchem.db.MDTableHandler`	`chemaxon.jchem.descriptors.MDTableHandler`
`chemaxon.jchem.db.RecalculationException`	`chemaxon.jchem.db.exceptions.RecalculationException`
`chemaxon.jchem.db.RegenerationConstants`	`chemaxon.jchem.db.constants.RegenerationConstants`
`chemaxon.jchem.db.StructureTableOptions`	`chemaxon.jchem.db.TableOptions`
`chemaxon.jchem.db.TableTypeConstants`	`chemaxon.jchem.db.constants.TableTypeConstants`
`chemaxon.jchem.db.Transfer`	`chemaxon.jchem.db.constants.TableTransferConstants`
`chemaxon.jchem.db.TransferException`	`chemaxon.jchem.db.exceptions.TableTransferException`
`chemaxon.jchem.db.Updater`	`chemaxon.jchem.db.DatabaseUpdater`
`chemaxon.jchem.db.UpdateHandler`	`chemaxon.jchem.db.TableUpdateHandler`
`chemaxon.jchem.db.UpdateHandlerException`	`chemaxon.jchem.db.exceptions.TableUpdateHandlerException`
`chemaxon.jchem.file.ProgressWriter`	`chemaxon.jchem.db.ProgressWriter`
`chemaxon.jep.ChemContext`	`chemaxon.chemterms.ChemTermsContext`
`chemaxon.jep.ChemJEP`	`chemaxon.chemterms.ChemTermsExpression`
`chemaxon.jep.ConstantTable`	`chemaxon.chemterms.ConstantTable`
`chemaxon.jep.ConstantTableBuilder`	`chemaxon.chemterms.ConstantTableBuilder`
`chemaxon.jep.CustomFunction`	`chemaxon.chemterms.CustomFunction`
`chemaxon.jep.Evaluator`	`chemaxon.chemterms.ChemTermsEvaluator`
`chemaxon.jep.FingerprintGenerator`	`chemaxon.chemterms.FingerprintGenerator`
`chemaxon.jep.JepException`	`chemaxon.chemterms.ChemTermsException`
`chemaxon.jep.context.AtomContext`	`chemaxon.chemterms.AtomContext`
`chemaxon.jep.context.MolContext`	`chemaxon.chemterms.MolContext`
`chemaxon.jep.context.ReactionContext`	`chemaxon.chemterms.ReactionContext`
`chemaxon.jep.context.SearchContext`	`chemaxon.chemterms.SearchContext`
`chemaxon.license.Licensable`	`chemaxon.license.api.Licensable`
`chemaxon.license.LicenseException`	`chemaxon.license.api.LicenseException`
`chemaxon.marvin.MolPrinter`	`chemaxon.marvin.beans.MolPrinter`
`chemaxon.marvin.alignment.Alignment`	`chemaxon.alignment.Alignment`
`chemaxon.marvin.alignment.AlignmentAccuracyMode`	`chemaxon.alignment.AlignmentAccuracyMode`
`chemaxon.marvin.alignment.AlignmentBase`	`chemaxon.alignment.AlignmentBase`
`chemaxon.marvin.alignment.AlignmentException`	`chemaxon.alignment.AlignmentException`
`chemaxon.marvin.alignment.AlignmentMolecule`	`chemaxon.alignment.AlignmentMolecule`
`chemaxon.marvin.alignment.AlignmentMoleculeFactory`	`chemaxon.alignment.AlignmentMoleculeFactory`
`chemaxon.marvin.alignment.AlignmentProperties`	`chemaxon.alignment.AlignmentProperties`
`chemaxon.marvin.alignment.AlignmentResult`	`chemaxon.alignment.AlignmentResult`
`chemaxon.marvin.alignment.AlignOnPairedAtoms`	`chemaxon.alignment.AlignOnPairedAtoms`
`chemaxon.marvin.alignment.AlignRigidEasy`	`chemaxon.alignment.AlignRigidEasy`
`chemaxon.marvin.alignment.AtropIsomerDetector`	`chemaxon.alignment.AtropIsomerDetector`
`chemaxon.marvin.alignment.DihedralRotator`	`chemaxon.alignment.DihedralRotator`
`chemaxon.marvin.alignment.MCSAlignment`	`chemaxon.alignment.MCSAlignment`
`chemaxon.marvin.alignment.MCSAlignmentResult`	`chemaxon.alignment.MCSAlignmentResult`
`chemaxon.marvin.alignment.MinMaxDistance`	`chemaxon.alignment.MinMaxDistance`
`chemaxon.marvin.alignment.MMPAlignment`	`chemaxon.alignment.MMPAlignment`
`chemaxon.marvin.alignment.MMPAlignmentProperties`	`chemaxon.alignment.MMPAlignmentProperties`
`chemaxon.marvin.alignment.MMPAlignmentResult`	`chemaxon.alignment.MMPAlignmentResult`
`chemaxon.marvin.alignment.MolAligner`	`chemaxon.alignment.MolAligner`
`chemaxon.marvin.alignment.NodeColor`	`chemaxon.alignment.NodeColor`
`chemaxon.marvin.alignment.PairwiseAlignment`	`chemaxon.alignment.PairwiseAlignment`
`chemaxon.marvin.alignment.PairwiseComparison`	`chemaxon.alignment.PairwiseComparison`
`chemaxon.marvin.alignment.PairwiseSimilarity3D`	`chemaxon.alignment.PairwiseSimilarity3D`
`chemaxon.marvin.alignment.Pharmacophore3D`	`chemaxon.alignment.Pharmacophore3D`
`chemaxon.marvin.alignment.RotatableBondDetector`	`chemaxon.alignment.RotatableBondDetector`
`chemaxon.marvin.alignment.ShapeData`	`chemaxon.alignment.ShapeData`
`chemaxon.marvin.alignment.atrop.BondInfo`	`chemaxon.alignment.DihedralScanResult.BondInfo`
`chemaxon.marvin.alignment.atrop.DihedralScanResult`	`chemaxon.alignment.DihedralScanResult`
`chemaxon.marvin.alignment.atrop.DihedralScanStep`	`chemaxon.alignment.DihedralScanResult.ScanStep`
`chemaxon.marvin.beans.MarvinPaneBeanInfo`	`chemaxon.marvin.beans.MarvinPaneBeanInfo`
`chemaxon.marvin.beans.MSketchPaneBeanInfo`	`chemaxon.marvin.beans.MSketchPaneBeanInfo`
`chemaxon.marvin.beans.MViewEditor`	`chemaxon.marvin.beans.MViewCellEditor`
`chemaxon.marvin.beans.MViewPaneBeanInfo`	`chemaxon.marvin.beans.MViewPaneBeanInfo`
`chemaxon.marvin.beans.MViewRenderer`	`chemaxon.marvin.beans.MViewCellRenderer`
`chemaxon.marvin.calculations.AlignmentPlugin`	`chemaxon.calculations.AlignmentPlugin`
`chemaxon.marvin.calculations.ChargePlugin`	`chemaxon.calculations.ChargePlugin`
`chemaxon.marvin.calculations.ConformerPlugin`	`chemaxon.calculations.ConformerPlugin`
`chemaxon.marvin.calculations.ElementalAnalyserPlugin`	`chemaxon.calculations.ElementalAnalysisPlugin`
`chemaxon.marvin.calculations.GeometryPlugin`	`chemaxon.calculations.GeometryPlugin`
`chemaxon.marvin.calculations.HBDAPlugin`	`chemaxon.calculations.HBDAPlugin`
`chemaxon.marvin.calculations.HergPlugin`	`chemaxon.calculations.admet.HergPlugin`
`chemaxon.marvin.calculations.HlbPlugin`	`chemaxon.calculations.HLBPlugin`
`chemaxon.marvin.calculations.HuckelAnalysisPlugin`	`chemaxon.calculations.HuckelAnalysisPlugin`
`chemaxon.marvin.calculations.IonChargePlugin`	`chemaxon.calculations.IonChargePlugin`
`chemaxon.marvin.calculations.IsoelectricPointPlugin`	`chemaxon.calculations.IsoelectricPointPlugin`
`chemaxon.marvin.calculations.IUPACNamingPlugin`	`chemaxon.calculations.ChemicalNamePlugin`
`chemaxon.marvin.calculations.logDPlugin`	`chemaxon.calculations.LogDPlugin`
`chemaxon.marvin.calculations.logPPlugin`	`chemaxon.calculations.LogPPlugin`
`chemaxon.marvin.calculations.LogPMethod`	`chemaxon.calculations.LogPMethod`
`chemaxon.marvin.calculations.MajorMicrospeciesAccessorPlugin`	`chemaxon.calculations.MajorMicrospeciesAccessorPlugin`
`chemaxon.marvin.calculations.MajorMicrospeciesPlugin`	`chemaxon.calculations.MajorMicrospeciesPlugin`
`chemaxon.marvin.calculations.MarkushEnumerationPlugin`	`chemaxon.calculations.MarkushEnumerationPlugin`
`chemaxon.marvin.calculations.MolecularDynamicsPlugin`	`chemaxon.calculations.MolecularDynamicsPlugin`
`chemaxon.marvin.calculations.MSAPlugin`	`chemaxon.calculations.MSAPlugin`
`chemaxon.marvin.calculations.OrbitalElectronegativityPlugin`	`chemaxon.calculations.OrbitalElectronegativityPlugin`
`chemaxon.marvin.calculations.PkaPlugin`	`chemaxon.calculations.PkaPlugin`
`chemaxon.marvin.calculations.pKaPlugin`	`chemaxon.calculations.PkaPlugin`
`chemaxon.marvin.calculations.PolarizabilityPlugin`	`chemaxon.calculations.PolarizabilityPlugin`
`chemaxon.marvin.calculations.RefractivityPlugin`	`chemaxon.calculations.RefractivityPlugin`
`chemaxon.marvin.calculations.ResonancePlugin`	`chemaxon.calculations.ResonancePlugin`
`chemaxon.marvin.calculations.StereoisomerPlugin`	`chemaxon.calculations.StereoisomerPlugin`
`chemaxon.marvin.calculations.StructuralFrameworksPlugin`	`chemaxon.calculations.StructuralFrameworksPlugin`
`chemaxon.marvin.calculations.TautomerizationPlugin`	`chemaxon.calculations.TautomerPlugin`
`chemaxon.marvin.calculations.TopologyAnalyserPlugin`	`chemaxon.calculations.TopologyAnalysisPlugin`
`chemaxon.marvin.calculations.TPSAPlugin`	`chemaxon.calculations.TPSAPlugin`
`chemaxon.marvin.io.Encoding`	`chemaxon.formats.Encoding`
`chemaxon.marvin.io.MDocSource`	`chemaxon.formats.MDocSource`
`chemaxon.marvin.io.MolExportException`	`chemaxon.formats.MolExportException`
`chemaxon.marvin.io.MolExportModule`	`chemaxon.formats.MolExportModule`
`chemaxon.marvin.io.MolImportModule`	`chemaxon.formats.MolImportModule`
`chemaxon.marvin.io.MPropHandler`	`chemaxon.formats.MPropHandler`
`chemaxon.marvin.io.PositionedInputStream`	`chemaxon.formats.PositionedInputStream`
`chemaxon.marvin.io.formats.MoleculeImporter`	`chemaxon.formats.MoleculeImporter`
`chemaxon.marvin.io.formats.MoleculeImporterIface`	`chemaxon.formats.MolImporterInterface`
`chemaxon.marvin.modules.datatransfer.MarvinTransferable`	`chemaxon.marvin.datatransfer.MarvinTransferable`
`chemaxon.marvin.modules.datatransfer.MTransferable`	`chemaxon.marvin.datatransfer.MTransferable`
`chemaxon.marvin.modules.datatransfer.TransferableDescriptor`	`chemaxon.marvin.datatransfer.TransferableDescriptor`
`chemaxon.marvin.paint.DispOptConsts`	`chemaxon.rendering.constants.DispOptConsts`
`chemaxon.marvin.paint.constants.AnyBondStyle`	`chemaxon.rendering.constants.AnyBondStyle`
`chemaxon.marvin.paint.constants.CoordinateBondOnMulticenterStyle`	`chemaxon.rendering.constants.CoordinateBondOnMulticenterStyle`
`chemaxon.marvin.paint.constants.CoordinateBondStyle`	`chemaxon.rendering.constants.CoordinateBondStyle`
`chemaxon.marvin.paint.constants.RenderingStyle`	`chemaxon.rendering.constants.RenderingStyle`
`chemaxon.marvin.plugin.CalculatorPlugin`	`chemaxon.calculations.CalculatorPlugin`
`chemaxon.marvin.plugin.CalculatorPluginService`	`chemaxon.calculations.CalculatorPluginService`
`chemaxon.marvin.plugin.PluginException`	`chemaxon.calculations.CalculatorPluginException`
`chemaxon.marvin.plugin.PluginInputCheckerException`	`chemaxon.calculations.CalculatorPluginInputException`
`chemaxon.marvin.plugin.PluginMDocSource`	`chemaxon.calculations.CalculatorPluginMDocSource`
`chemaxon.marvin.services.AsyncCallback`	`chemaxon.calculations.services.AsyncCallback`
`chemaxon.marvin.services.DynamicArgument`	`chemaxon.calculations.services.DynamicArgument`
`chemaxon.marvin.services.ServiceArgument`	`chemaxon.calculations.services.ServiceArgument`
`chemaxon.marvin.services.ServiceDescriptor`	`chemaxon.calculations.services.ServiceDescriptor`
`chemaxon.marvin.services.ServiceDescriptorReader`	`chemaxon.calculations.services.ServiceDescriptorReader`
`chemaxon.marvin.services.ServiceDescriptorTools`	`chemaxon.calculations.services.ServiceDescriptorTools`
`chemaxon.marvin.services.ServiceDescriptorWriter`	`chemaxon.calculations.services.ServiceDescriptorWriter`
`chemaxon.marvin.services.ServiceException`	`chemaxon.calculations.services.ServiceException`
`chemaxon.marvin.services.ServiceHandler`	`chemaxon.calculations.services.ServiceHandler`
`chemaxon.marvin.services.httpservice.HTTPServiceDescriptor`	`chemaxon.calculations.services.HttpServiceDescriptor`
`chemaxon.marvin.services.httpservice.HTTPServiceHandler`	`chemaxon.calculations.services.HttpServiceHandler`
`chemaxon.marvin.services.json.JsonServiceDescriptor`	`chemaxon.calculations.services.JsonServiceDescriptor`
`chemaxon.marvin.services.json.JsonServiceHandler`	`chemaxon.calculations.services.JsonServiceHandler`
`chemaxon.marvin.services.localservice.LocalServiceDescriptor`	`chemaxon.calculations.services.LocalServiceDescriptor`
`chemaxon.marvin.services.localservice.LocalServiceHandler`	`chemaxon.calculations.services.LocalServiceHandler`
`chemaxon.marvin.sketch.SketchParameterConstants`	`chemaxon.marvin.common.SketchParameterConstants`
`chemaxon.marvin.swing.MAction`	`chemaxon.marvin.common.MAction`
`chemaxon.marvin.util.CleanUtil`	`chemaxon.core.calculations.clean.CleanUtil`
`chemaxon.marvin.util.OptionDescriptor`	`chemaxon.formats.OptionDescriptor`
`chemaxon.marvin.view.CellType`	`chemaxon.marvin.common.CellType`
`chemaxon.marvin.view.MDocStorage`	`chemaxon.marvin.common.MDocStorage`
`chemaxon.marvin.view.ViewParameterConstants`	`chemaxon.marvin.common.ViewParameterConstants`
`chemaxon.marvin.view.swing.TableOptions`	`chemaxon.marvin.common.TableOptions`
`chemaxon.marvin.view.swing.TableSupport`	`chemaxon.marvin.common.TableSupport`
`chemaxon.naming.document.annotate.DocumentAnnotator`	`chemaxon.naming.document.DocumentAnnotator`
`chemaxon.naming.document.annotate.DocumentAnnotatorOptions`	`chemaxon.naming.document.DocumentAnnotatorOptions`
`chemaxon.naming.document.annotate.XmlToHtmlConverter`	`chemaxon.naming.document.XmlToHtmlConverter`
`chemaxon.nfunk.jep.ParseException`	`chemaxon.chemterms.ParseException`
`chemaxon.pharmacophore.PMap`	`chemaxon.descriptors.pharmacophore.PMap`
`chemaxon.pharmacophore.PMapper`	`chemaxon.descriptors.pharmacophore.PMapper`
`chemaxon.pharmacophore.PSymbols`	`chemaxon.descriptors.pharmacophore.PSymbols`
`chemaxon.sss.SearchConstants`	`chemaxon.search.api.SearchConstants`
`chemaxon.sss.formula.FormulaSearch`	`chemaxon.search.FormulaSearch`
`chemaxon.sss.screen.HashCode`	`chemaxon.search.util.HashCode`
`chemaxon.sss.screen.Similarity`	`chemaxon.search.util.SimilarityUtil`
`chemaxon.sss.screen.StrucFPConfig`	`chemaxon.jchem.db.StructuralKeyConfig`
`chemaxon.sss.search.Decomposition`	`chemaxon.search.Decomposition`
`chemaxon.sss.search.JChemSearchOptions`	`chemaxon.jchem.db.JChemSearchOptions`
`chemaxon.sss.search.MarkushGenerator`	`chemaxon.search.MarkushGenerator`
`chemaxon.sss.search.MatchCountOptions`	`chemaxon.jchem.db.MatchCountOptions`
`chemaxon.sss.search.MolComparator`	`chemaxon.search.api.MolComparator`
`chemaxon.sss.search.MolSearch`	`chemaxon.search.MolSearch`
`chemaxon.sss.search.MolSearchOptions`	`chemaxon.search.api.options.MolSearchOptions`
`chemaxon.sss.search.RgDecompResults`	`chemaxon.search.RgroupDecompositionResults`
`chemaxon.sss.search.RGroupDecomposition`	`chemaxon.search.RgroupDecomposition`
`chemaxon.sss.search.Search`	`chemaxon.search.AbstractSearch`
`chemaxon.sss.search.SearchException`	`chemaxon.search.api.SearchException`
`chemaxon.sss.search.SearchHit`	`chemaxon.search.api.SearchHit`
`chemaxon.sss.search.SearchOptions`	`chemaxon.search.api.options.SearchOptions`
`chemaxon.sss.search.SearchTimeoutException`	`chemaxon.search.api.SearchTimeoutException`
`chemaxon.sss.search.StandardizedMolSearch`	`chemaxon.search.StandardizedMolSearch`
`chemaxon.sss.search.UnsupportedQueryException`	`chemaxon.search.api.UnsupportedQueryException`
`chemaxon.sss.search.options.HaltOnErrorOption`	`chemaxon.search.api.options.HaltOnErrorOption`
`chemaxon.sss.search.options.HasOptionString`	`chemaxon.search.api.options.OptionStringProvider`
`chemaxon.sss.search.options.HomologyTranslationOption`	`chemaxon.search.api.options.HomologyTranslationOption`
`chemaxon.sss.search.options.MarkushAromaticityHandlingOption`	`chemaxon.search.api.options.MarkushAromaticityHandlingOption`
`chemaxon.sss.search.options.SetOfSmallestRingsOption`	`chemaxon.search.api.options.SetOfSmallestRingsOption`
`chemaxon.sss.search.options.TargetHomologyMatchingMode`	`chemaxon.search.api.options.TargetHomologyMatchingMode`
`chemaxon.sss.search.options.TautomerEqualityMode`	`chemaxon.search.api.options.TautomerEqualityMode`
`chemaxon.sss.search.options.TautomerSubstructureMode`	`chemaxon.search.api.options.TautomerSubstructureMode`
`chemaxon.sss.search.options.TautomerTransformationMode`	`chemaxon.search.api.options.TautomerTransformationMode`
`chemaxon.standardizer.Persistent`	`chemaxon.standardizer.PersistentProperty`
`chemaxon.standardizer.actions.AbstractSgroupAction`	`chemaxon.standardizer.AbstractSgroupAction`
`chemaxon.standardizer.advancedactions.Clean2DAction`	`chemaxon.standardizer.actions.Clean2DAction`
`chemaxon.standardizer.advancedactions.Clean3DAction`	`chemaxon.standardizer.actions.Clean3DAction`
`chemaxon.standardizer.advancedactions.CreateGroupAction`	`chemaxon.standardizer.actions.CreateGroupAction`
`chemaxon.standardizer.advancedactions.GroupDefinition`	`chemaxon.standardizer.actions.GroupDefinition`
`chemaxon.standardizer.advancedactions.RemoveSolventsAction`	`chemaxon.standardizer.actions.RemoveSolventsAction`
`chemaxon.standardizer.advancedactions.StripSaltsAction`	`chemaxon.standardizer.actions.StripSaltsAction`
`chemaxon.standardizer.advancedactions.TransformAction`	`chemaxon.standardizer.actions.TransformAction`
`chemaxon.standardizer.configuration.reader.StandardizerActionStringReader`	`chemaxon.standardizer.configuration.StandardizerActionStringReader`
`chemaxon.standardizer.configuration.reader.StandardizerConfigurationReader`	`chemaxon.standardizer.configuration.StandardizerConfigurationReader`
`chemaxon.standardizer.configuration.reader.StandardizerXMLReader`	`chemaxon.standardizer.configuration.StandardizerConfigurationXmlReader`
`chemaxon.standardizer.configuration.writer.StandardizerActionStringWriter`	`chemaxon.standardizer.configuration.StandardizerActionStringWriter`
`chemaxon.standardizer.configuration.writer.StandardizerConfigurationWriter`	`chemaxon.standardizer.configuration.StandardizerConfigurationWriter`
`chemaxon.standardizer.configuration.writer.StandardizerXMLWriter`	`chemaxon.standardizer.configuration.StandardizerConfigurationXmlWriter`
`chemaxon.struc.AbstractAtropStereoDescriptor`	`chemaxon.core.calculations.stereo.AbstractAtropStereoDescriptor`
`chemaxon.struc.AbstractAxialStereoDescriptor`	`chemaxon.core.calculations.stereo.AbstractAxialStereoDescriptor`
`chemaxon.struc.AbstractCisTransStereoDescriptor`	`chemaxon.core.calculations.stereo.AbstractCisTransStereoDescriptor`
`chemaxon.struc.AbstractTetrahedralStereoDescriptor`	`chemaxon.core.calculations.stereo.AbstractTetrahedralStereoDescriptor`
`chemaxon.struc.AtomProperty.Radical`	`chemaxon.struc.Radical`
`chemaxon.struc.AtropStereoDescriptor`	`chemaxon.core.calculations.stereo.AtropStereoDescriptor`
`chemaxon.struc.AtropStereoIUPACDescriptor`	`chemaxon.core.calculations.stereo.AtropStereoIUPACDescriptor`
`chemaxon.struc.AxialStereoDescriptor`	`chemaxon.core.calculations.stereo.AxialStereoDescriptor`
`chemaxon.struc.AxialStereoIUPACDescriptor`	`chemaxon.core.calculations.stereo.AxialStereoIUPACDescriptor`
`chemaxon.struc.CisTransStereoDescriptor`	`chemaxon.core.calculations.stereo.CisTransStereoDescriptor`
`chemaxon.struc.CisTransStereoIUPACDescriptor`	`chemaxon.core.calculations.stereo.CisTransStereoIUPACDescriptor`
`chemaxon.struc.CIPStereoDescriptorIface`	`chemaxon.core.calculations.stereo.CIPStereoDescriptor`
`chemaxon.struc.CIPStereoDescriptorIface.CIPType`	`chemaxon.core.calculations.stereo.CIPStereoType`
`chemaxon.struc.CIPStereoDescriptorIface.CIPValue`	`chemaxon.core.calculations.stereo.CIPStereoValue`
`chemaxon.struc.CTransform3D`	`chemaxon.struc.Transform3D`
`chemaxon.struc.DPoint3`	`chemaxon.struc.Point3D`
`chemaxon.struc.PeriodicSystem`	`chemaxon.struc.PeriodicTable` (*)
`chemaxon.struc.RgMoleculeGraphIface`	`chemaxon.struc.RgMoleculeGraph`
`chemaxon.struc.StereoActivePart`	`chemaxon.core.calculations.stereo.StereoActivePart`
`chemaxon.struc.TetrahedralStereoDescriptor`	`chemaxon.core.calculations.stereo.TetrahedralStereoDescriptor`
`chemaxon.struc.TetrahedralStereoIUPACDescriptor`	`chemaxon.core.calculations.stereo.TetrahedralStereoIUPACDescriptor`
`chemaxon.struc.graphics.analysis.MAnalysisBoxTerm`	`chemaxon.struc.graphics.MAnalysisBoxTerm`
`chemaxon.struc.stereo.EZConfiguration`	`chemaxon.struc.EZConfiguration`
`chemaxon.structurechecker.factory.CheckerFixerFactory`	`chemaxon.structurechecker.CheckerFixerFactory`
`chemaxon.util.ConnectionHandler`	`chemaxon.jchem.util.ConnectionHandler`
`chemaxon.util.DatabaseTools`	`chemaxon.jchem.db.DatabaseTools`
`chemaxon.util.ErrorHandler`	`chemaxon.jchem.util.ErrorHandler`
`chemaxon.util.ErrorProcessor`	`chemaxon.formats.ErrorProcessor`
`chemaxon.util.HitColoringAndAlignmentOptions`	`chemaxon.search.hitdisplay.HitDisplayOptions`
`chemaxon.util.HitDisplayTool`	`chemaxon.search.hitdisplay.HitDisplayTool`
`chemaxon.util.HitDisplayUtil`	`chemaxon.search.hitdisplay.HitDisplayUtil`
`chemaxon.util.ImageExportUtil`	`chemaxon.marvin.util.ImageExportUtil`
`chemaxon.util.MolFilter`	`chemaxon.core.util.MolFilter`
`chemaxon.util.MolHandler`	`chemaxon.jchem.db.MolHandler`
`chemaxon.util.ValenceFilter`	`chemaxon.core.util.ValenceFilter`
`chemaxon.util.iterator.IteratorFactory`	`chemaxon.struc.IteratorFactory`
`chemaxon.util.iterator.MoleculeIterator`	`chemaxon.formats.MoleculeIterator`
`chemaxon.util.iterator.MoleculeIteratorFactory`	`chemaxon.formats.MoleculeIteratorFactory`
`chemaxon.util.progress.ProgressObserver`	`chemaxon.clustering.common.ProgressObserver`
`com.chemaxon.calculations.admet.HergActivityPrediction`	`chemaxon.calculations.admet.HergActivityPrediction`
`com.chemaxon.calculations.admet.HergActivityPredictor`	`chemaxon.calculations.admet.HergActivityPredictor`
`com.chemaxon.calculations.admet.HergClass`	`chemaxon.calculations.admet.HergClass`
`com.chemaxon.calculations.admet.HergClassPrediction`	`chemaxon.calculations.admet.HergClassPrediction`
`com.chemaxon.calculations.admet.HergClassPredictor`	`chemaxon.calculations.admet.HergClassPredictor`
`com.chemaxon.calculations.cli.CalculatorPluginOutput`	`chemaxon.calculations.output.CalculatorPluginOutput`
`com.chemaxon.calculations.cli.CalculatorResultAccess`	`chemaxon.calculations.output.CalculatorPluginOutputAccess`
`com.chemaxon.calculations.elemanal.ElementalAnalysis`	`chemaxon.calculations.elemental.ElementalAnalysis`
`com.chemaxon.calculations.elemanal.FormulaGenerationRule`	`chemaxon.calculations.elemental.FormulaGenerationRule`
`com.chemaxon.calculations.elemanal.factory.ElementalAnalysisFactory`	`chemaxon.calculations.elemental.ElementalAnalysisFactory`
`com.chemaxon.calculations.elemanal.formula.FormulaAtom`	`chemaxon.calculations.elemental.FormulaAtom`
`com.chemaxon.calculations.gui.CalculatorPluginDisplay`	`chemaxon.calculations.gui.CalculatorPluginDisplay`
`com.chemaxon.calculations.gui.MChart`	`chemaxon.calculations.gui.MChart`
`com.chemaxon.calculations.gui.ParameterPanelHandler`	`chemaxon.calculations.gui.ParameterPanelHandler`
`com.chemaxon.calculations.gui.PluginFactory`	`chemaxon.calculations.gui.PluginFactory`
`com.chemaxon.calculations.solubility.DefaultSolubilityCategory`	`chemaxon.calculations.solubility.DefaultSolubilityCategory`
`com.chemaxon.calculations.solubility.SolubilityCalculator`	`chemaxon.calculations.solubility.SolubilityCalculator`
`com.chemaxon.calculations.solubility.SolubilityCategories`	`chemaxon.calculations.solubility.SolubilityCategories`
`com.chemaxon.calculations.solubility.SolubilityCategory`	`chemaxon.calculations.solubility.SolubilityCategory`
`com.chemaxon.calculations.solubility.SolubilityResult`	`chemaxon.calculations.solubility.SolubilityResult`
`com.chemaxon.calculations.solubility.SolubilityUnit`	`chemaxon.calculations.solubility.SolubilityUnit`
`com.chemaxon.calculations.stereoanal.ErrorReport`	`chemaxon.calculations.stereo.ErrorReport`
`com.chemaxon.calculations.stereoanal.StereoAnalysis`	`chemaxon.calculations.stereo.StereoAnalysis`
`com.chemaxon.calculations.stereoanal.StereoConstants.EnhancedStereoType`	`chemaxon.calculations.stereo.stereocenters.EnhancedStereoType`
`com.chemaxon.calculations.stereoanal.StereoConstants.Type`	`chemaxon.calculations.stereo.stereocenters.StereoType`
`com.chemaxon.calculations.stereoanal.filters.StereoCenterVisitor`	`chemaxon.calculations.stereo.stereocenters.StereoCenterVisitor`
`com.chemaxon.calculations.stereoanal.stereocenters.AtomSelection`	`chemaxon.calculations.stereo.stereocenters.AtomSelection`
`com.chemaxon.calculations.stereoanal.stereocenters.AtropStereoCenter`	`chemaxon.calculations.stereo.stereocenters.AtropStereoCenter`
`com.chemaxon.calculations.stereoanal.stereocenters.AttachedData`	`chemaxon.calculations.stereo.stereocenters.AttachedData`
`com.chemaxon.calculations.stereoanal.stereocenters.AxialStereoCenter`	`chemaxon.calculations.stereo.stereocenters.AxialStereoCenter`
`com.chemaxon.calculations.stereoanal.stereocenters.CisTransStereoCenter`	`chemaxon.calculations.stereo.stereocenters.CisTransStereoCenter`
`com.chemaxon.calculations.stereoanal.stereocenters.EnhancedStereo`	`chemaxon.calculations.stereo.stereocenters.EnhancedStereo`
`com.chemaxon.calculations.stereoanal.stereocenters.EnhancedStereoGroup`	`chemaxon.calculations.stereo.stereocenters.EnhancedStereoGroup`
`com.chemaxon.calculations.stereoanal.stereocenters.StereoCenter`	`chemaxon.calculations.stereo.stereocenters.StereoCenter`
`com.chemaxon.calculations.stereoanal.stereocenters.TetrahedralStereoCenter`	`chemaxon.calculations.stereo.stereocenters.TetrahedralStereoCenter`
`com.chemaxon.calculations.stereoisomers.StereoisomerEnumeration`	`chemaxon.calculations.stereo.StereoisomerEnumeration`
`com.chemaxon.calculations.stereoisomers.StereoisomerSettings`	`chemaxon.calculations.stereo.StereoisomerSettings`
`com.chemaxon.clustering.common.Cluster`	`chemaxon.clustering.common.Cluster`
`com.chemaxon.clustering.common.DissimilarityInput`	`chemaxon.clustering.common.DissimilarityInput`
`com.chemaxon.clustering.common.HierarchicCluster`	`chemaxon.clustering.common.HierarchicCluster`
`com.chemaxon.clustering.common.HierarchicClustering`	`chemaxon.clustering.common.HierarchicClustering`
`com.chemaxon.clustering.common.IDBasedAssigner`	`chemaxon.clustering.common.IDBasedAssigner`
`com.chemaxon.clustering.common.IDBasedAssignerBuilder`	`chemaxon.clustering.common.IDBasedAssignerBuilder`
`com.chemaxon.clustering.common.IDBasedClusterBuilder`	`chemaxon.clustering.common.IDBasedClusterBuilder`
`com.chemaxon.clustering.common.IDBasedClusterBuilderSpec`	`chemaxon.clustering.common.IDBasedClusterBuilderSpec`
`com.chemaxon.clustering.common.IDBasedHierarchicCluster`	`chemaxon.clustering.common.IDBasedHierarchicCluster`
`com.chemaxon.clustering.common.IDBasedHierarchicClusterBuilder`	`chemaxon.clustering.common.IDBasedHierarchicClusterBuilder`
`com.chemaxon.clustering.common.IDBasedHierarchicClustering`	`chemaxon.clustering.common.IDBasedHierarchicClustering`
`com.chemaxon.clustering.common.IDBasedHierarchy`	`chemaxon.clustering.common.IDBasedHierarchy`
`com.chemaxon.clustering.common.IDBasedSingleLevelClustering`	`chemaxon.clustering.common.IDBasedSingleLevelClustering`
`com.chemaxon.clustering.common.LevelAssigner`	`chemaxon.clustering.common.LevelAssigner`
`com.chemaxon.clustering.common.PhasedProgressObserver`	`chemaxon.clustering.common.PhasedProgressObserver`
`com.chemaxon.clustering.common.ProgressObserver`	`chemaxon.clustering.common.ProgressObserver`
`com.chemaxon.clustering.common.SingleLevelClustering`	`chemaxon.clustering.common.SingleLevelClustering`
`com.chemaxon.clustering.framework.BemisMurckoClustering`	`chemaxon.clustering.framework.BemisMurckoClustering`
`com.chemaxon.clustering.framework.FrameworkClusteringResults`	`chemaxon.clustering.framework.FrameworkClusteringResults`
`com.chemaxon.clustering.framework.OrderedElement`	`chemaxon.clustering.framework.OrderedElement`
`com.chemaxon.clustering.singlelinkage.SingleLinkage`	`chemaxon.clustering.SingleLinkageClustering`
`com.chemaxon.clustering.sphex.SphereExclusion`	`chemaxon.clustering.SphereExclusion`
`com.chemaxon.clustering.util.ClusteringUtils`	`chemaxon.clustering.util.ClusteringUtils`
`com.chemaxon.clustering.util.PostOrderDfsVisitor`	`chemaxon.clustering.util.PostOrderDfsVisitor`
`com.chemaxon.clustering.util.SimpleDfsVisitor`	`chemaxon.clustering.util.SimpleDfsVisitor`
`com.chemaxon.clustering.util.Util`	`chemaxon.clustering.util.ClusteringUtils`
`com.chemaxon.clustering.wards.LanceWilliamsAlgorithm`	`chemaxon.clustering.LanceWilliamsAlgorithm`
`com.chemaxon.clustering.wards.LanceWilliamsMerge`	`chemaxon.clustering.LanceWilliamsMerge`
`com.chemaxon.clustering.wards.LanceWilliamsMerges`	`chemaxon.clustering.LanceWilliamsMerges`
`com.chemaxon.common.annotations.Beta`	`chemaxon.common.annotations.Beta`
`com.chemaxon.common.annotations.PublicApi`	`chemaxon.common.annotations.PublicApi`
`com.chemaxon.common.annotations.RemovalDate`	`chemaxon.common.annotations.RemovalDate`
`com.chemaxon.common.annotations.SubjectToRemoval`	`chemaxon.common.annotations.SubjectToRemoval`
`com.chemaxon.mapper.AutoMapper`	`chemaxon.reaction.mapper.AutoMapper`
`com.chemaxon.mapper.Mapper`	`chemaxon.reaction.mapper.ReactionMapper`
`com.chemaxon.search.mcs.MaxCommonSubstructure`	`chemaxon.search.mcs.MaxCommonSubstructure`
`com.chemaxon.search.mcs.McsCustomMatcher`	`chemaxon.search.mcs.McsCustomMatcher`
`com.chemaxon.search.mcs.McsCustomMatcherFactory`	`chemaxon.search.mcs.McsCustomMatcherFactory`
`com.chemaxon.search.mcs.McsSearchOptions`	`chemaxon.search.mcs.McsSearchOptions`
`com.chemaxon.search.mcs.McsSearchResult`	`chemaxon.search.mcs.McsSearchResult`
`com.chemaxon.search.mcs.RingHandlingMode`	`chemaxon.search.mcs.RingHandlingMode`
`com.chemaxon.search.mcs.SearchMode`	`chemaxon.search.mcs.McsSearchMode`
`com.chemaxon.search.mcs.buildup.BuildupMcs`	`chemaxon.search.mcs.BuildupMcs`
`com.chemaxon.search.mcs.maxclique.MaxCliqueMcs`	`chemaxon.search.mcs.MaxCliqueMcs`
`com.chemaxon.version.VersionInfo`	`chemaxon.common.version.VersionInfo`

(*) Note: PeriodicSystem and ChemConst are merged as a new class PeriodicTable.

Discontinued Classes¶

The following table lists the public API classes that are discontinued in version 26 with comments about replacement or alternatives. These classes are no longer available, so an alternative solution is necessary if you are using any of them. If you need advice or help, please contact Chemaxon support.

Class name (version 25)	Comment
`chemaxon.checkers.StereoCheckUtility`	no replacement
`chemaxon.checkers.StructureCheck`	no replacement
`chemaxon.checkers.StructureCheckOptions`	no replacement
`chemaxon.checkers.StructureCheckerFactory`	use `chemaxon.structurechecker.CheckerFixerFactory` instead
`chemaxon.checkers.StructureCheckerUtility`	no replacement
`chemaxon.checkers.WedgeErrorChecker`	use more specific stereo checkers instead
`chemaxon.checkers.result.ReactionCheckerResult`	no replacement
`chemaxon.checkers.runner.SketchCheckerRunner`	no replacement
`chemaxon.clustering.InvalidLicenseKeyException`	no replacement
`chemaxon.common.swing.io.output.FileSaveResult`	no replacement
`chemaxon.common.util.ArgumentException`	no replacement
`chemaxon.core.calculations.valencecheck.MoleculeWithValence`	use `Molecule` (or `MoleculeGraph`) instead
`chemaxon.descriptors.MolecularDescriptorGenerator`	no replacement
`chemaxon.fixers.AbsentChiralFlagFixer`	use `chemaxon.fixers.AddChiralFlagFixer` instead
`chemaxon.fixers.AbsoluteStereoFixer`	use `chemaxon.fixers.RemoveInvalidChiralFlagFixer` instead
`chemaxon.fixers.CrossedDoubleBondFixer`	use `chemaxon.fixers.ConvertToWigglyDoubleBondFixer` instead
`chemaxon.fixers.ExplicitHydrogenFixer`	use `chemaxon.fixers.RemoveExplicitHydrogenFixer` instead
`chemaxon.fixers.FixerPriorityComparator`	no replacement
`chemaxon.fixers.IsotopeFixer`	use `chemaxon.fixers.ConvertToElementalFormFixer` instead
`chemaxon.fixers.RemoveInvalidChiralFlagFixer`	use `chemaxon.fixers.RemoveChiralFlagFixer` instead
`chemaxon.fixers.StructureFixerFactory`	use `chemaxon.structurechecker.CheckerFixerFactory` instead
`chemaxon.fixers.WedgeCleanFixer`	use more specific stereo fixers instead
`chemaxon.fixers.WigglyDoubleBondFixer`	use `chemaxon.fixers.ConvertToCrossedDoubleBondFixer` instead
`chemaxon.formats.BinaryExporter`	no replacement
`chemaxon.formats.ExportOptions`	no replacement
`chemaxon.formats.GeneralExportOptions`	no replacement
`chemaxon.formats.ImportOptions`	no replacement
`chemaxon.formats.MdlCompressor`	no replacement
`chemaxon.formats.factory.MolExportModuleFactory`	no replacement
`chemaxon.formats.factory.MolImportModuleFactory`	no replacement
`chemaxon.formats.factory.MRecordReaderFactory`	no replacement
`chemaxon.formats.factory.RecognizerFactory`	no replacement
`chemaxon.formats.recognizer.AbbrevGroupRecognizer`	no replacement
`chemaxon.formats.recognizer.CubeRecognizer`	no replacement
`chemaxon.formats.recognizer.PDBRecognizer`	no replacement
`chemaxon.formats.recognizer.PeptideRecognizer`	no replacement
`chemaxon.formats.recognizer.RecognizerList`	no replacement
`chemaxon.formats.recognizer.SMILESRecognizer`	no replacement
`chemaxon.jchem.db.MaxSearchFrequencyExceededException`	no replacement
`chemaxon.jchem.db.PropertyConstants`	use `MetaDataConstants` instead
`chemaxon.jep.MolCondition`	no replacement
`chemaxon.marvin.alignment.atrop.DihedralScanListener`	no replacement
`chemaxon.marvin.beans.MarvinPaneBeanInfo`	no replacement
`chemaxon.marvin.beans.MSketchPaneBeanInfo`	no replacement
`chemaxon.marvin.beans.MViewPaneBeanInfo`	no replacement
`chemaxon.marvin.io.ArrayMDocSource`	no replacement
`chemaxon.marvin.io.MRecord`	no replacement
`chemaxon.marvin.io.MRecordImporter`	no replacement
`chemaxon.marvin.io.MRecordParseException`	no replacement
`chemaxon.marvin.io.MRecordReader`	no replacement
`chemaxon.marvin.io.fieldaccess.MFieldAccessor`	no replacement
`chemaxon.marvin.io.formats.AbstractMRecordReader`	no replacement
`chemaxon.marvin.io.formats.mdl.MolExport`	no replacement
`chemaxon.marvin.io.formats.mdl.MolImport`	no replacement
`chemaxon.marvin.io.formats.mdl.MolfileUtil`	no replacement
`chemaxon.marvin.io.formats.smiles.SmartsAtomQuerifier`	no replacement
`chemaxon.marvin.io.formats.vectgraphics.EmfExporter`	use `chemaxon.formats.MolExporter` instead
`chemaxon.marvin.io.formats.vectgraphics.PdfExporter`	use `chemaxon.formats.MolExporter` instead
`chemaxon.marvin.io.formats.vectgraphics.SvgExporter`	use `chemaxon.formats.MolExporter` instead
`chemaxon.marvin.io.image.ImageExportBaseUtil`	no replacement
`chemaxon.marvin.io.image.ImageExporter`	use `chemaxon.formats.MolExporter` instead
`chemaxon.marvin.io.image.ImageExportParamConstants`	no replacement
`chemaxon.marvin.io.image.exporter.JpegExporter`	use `chemaxon.formats.MolExporter` instead
`chemaxon.marvin.io.image.exporter.MsbmpExporter`	use `chemaxon.formats.MolExporter` instead
`chemaxon.marvin.io.image.exporter.PngExporter`	use `chemaxon.formats.MolExporter` instead
`chemaxon.marvin.plugin.concurrent.DefaultPluginWorkUnit`	no replacement
`chemaxon.marvin.plugin.concurrent.PluginExecutionException`	no replacement
`chemaxon.marvin.plugin.concurrent.PluginWorkUnit`	no replacement
`chemaxon.marvin.plugin.concurrent.ReusablePluginWorkUnit`	no replacement
`chemaxon.marvin.plugin.gui.OptionsPane`	no replacement
`chemaxon.marvin.plugin.gui.ParameterPanel`	no replacement
`chemaxon.marvin.plugin.gui.ParameterTab`	no replacement
`chemaxon.marvin.plugin.gui.ResultView`	no replacement
`chemaxon.marvin.services.ServiceDialogProvider`	no replacement
`chemaxon.marvin.services.soap.SoapServiceDescriptor`	no replacement, use RESTful web services instead
`chemaxon.marvin.services.soap.SoapServiceHandler`	no replacement, use RESTful web services instead
`chemaxon.marvin.services.ServiceDescriptorEditor`	no replacement
`chemaxon.marvin.services.ServiceDescriptorEditorProvider`	no replacement
`chemaxon.marvin.services.xmlrpcservice.XMLRPCServiceDescriptor`	no replacement, use RESTful web services instead
`chemaxon.marvin.services.xmlrpcservice.XMLRPCServiceHandler`	no replacement, use RESTful web services instead
`chemaxon.marvin.sketch.swing.modules.documentstyle.DocumentStyleAPI`	no replacement
`chemaxon.marvin.uif.dialog.LicenseDialog`	no replacement
`chemaxon.marvin.util.CopyOptConstants`	no replacement
`chemaxon.marvin.view.TaskScheduler`	no replacement
`chemaxon.nfunk.jep.function.PostfixMathCommandI`	no replacement
`chemaxon.reaction.ReactantSetEnumeration`	no replacement
`chemaxon.standardizer.actions.AbsoluteStereoAction`	use `SetAbsoluteStereoAction` or `RemoveAbsoluteStereoAction` instead
`chemaxon.standardizer.concurrent.StandardizerResult`	no replacement
`chemaxon.standardizer.concurrent.StandardizerRunner`	use `Standardizer` or `ConcurrentStandardizerProcessor` instead
`chemaxon.standardizer.runner.BasicStandardizerRunner`	use `Standardizer` or `ConcurrentStandardizerProcessor` instead
`chemaxon.standardizer.runner.StandardizerActionRunner`	use `Standardizer` or `ConcurrentStandardizerProcessor` instead
`chemaxon.struc.MObjectContainer`	use `Molecule` instead
`chemaxon.struc.Smolecule`	no replacement
`chemaxon.struc.AtomProperty`	no replacement
`chemaxon.util.HTMLTools`	no replacement
`chemaxon.util.UploadThread`	no replacement
`chemaxon.util.concurrent.marvin.MolInputProducer`	no replacement
`com.chemaxon.calculations.cli.CalculatorPluginCachedResults`	no replacement
`com.chemaxon.calculations.elemanal.factory.MolecularFormulas`	no replacement
`com.chemaxon.calculations.stereoanal.StereoConstants`	no replacement
`com.chemaxon.calculations.stereoanal.filters.*`	use `chemaxon.calculations.stereo.StereoAnalysis` instead
`com.chemaxon.clustering.common.UnitPathAssigner`	no replacement
`com.chemaxon.descriptors.*`	use classes from package `chemaxon.descriptors` instead
`com.chemaxon.overlap.*`	use classes from package `chemaxon.descriptors` instead
`com.chemaxon.search.AromatizationMethod`	no replacement
`com.chemaxon.search.SimpleSearcher`	use `MolSearch` or `StandardizedMolSearch` instead
`com.chemaxon.search.SimpleSearcherFactory`	use `MolSearch` or `StandardizedMolSearch` instead
`com.chemaxon.search.mcs.upperbound.FastUpperBoundCalculator`	use `MaxCommonSubstructure` instead
`com.chemaxon.search.mcs.upperbound.StandardUpperBoundCalculator`	use `MaxCommonSubstructure` instead
`com.chemaxon.search.mcs.upperbound.UpperBoundCalculator`	use `MaxCommonSubstructure` instead
`com.chemaxon.search.transformation.*`	use `MolSearch` or `StandardizedMolSearch` instead
`com.chemaxon.util.concurrent.CloseableIterator`	no replacement