/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.openjpa.persistence;

import java.util.Collection;
import java.util.EnumSet;
import java.util.Set;

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.LockModeType;
import jakarta.persistence.Query;

import org.apache.openjpa.event.CallbackModes;
import org.apache.openjpa.kernel.AutoClear;
import org.apache.openjpa.kernel.AutoDetach;
import org.apache.openjpa.kernel.ConnectionRetainModes;
import org.apache.openjpa.kernel.DetachState;
import org.apache.openjpa.kernel.RestoreState;
import org.apache.openjpa.persistence.criteria.OpenJPACriteriaBuilder;
import org.apache.openjpa.persistence.query.QueryDefinition;

/**
 * Interface implemented by OpenJPA entity managers.
 *
 * This interface extends {@link EntityTransaction}, but this extension is
 * deprecated.
 *
 * @since 0.4.0
 * @author Abe White
 * @published
 */
public interface OpenJPAEntityManager
    extends EntityManager, EntityTransaction /* deprecated */ {

    /**
     * Return the factory that produced this entity manager.
     */
    @Override OpenJPAEntityManagerFactory getEntityManagerFactory();

    /**
     * Return the (mutable) fetch plan for loading objects from this
     * entity manager.
     */
    FetchPlan getFetchPlan();

    /**
     * Pushes a new fetch plan that inherits from the current fetch plan onto
     * a stack, and makes the new plan the active one.
     *
     * @since 1.1.0
     * @return the new fetch plan
     */
    FetchPlan pushFetchPlan();

    /**
     * Pops the fetch plan from the top of the stack, making the next one down
     * the active one. This returns void to avoid confusion, since fetch plans
     * tend to be used in method-chaining patterns often.
     *
     * @since 1.1.0
     */
    void popFetchPlan();

    /**
     * Return the connection retain mode for this entity manager.
     */
    ConnectionRetainMode getConnectionRetainMode();

    /**
     * Whether this entity manager is using managed transactions.
     *
     * @since 1.1.0
     */
    boolean isTransactionManaged();

    /**
     * @deprecated use {@link #isTransactionManaged} instead to interrogate
     * whether or not this EntityManager's transaction is managed. To determine
     * if a given entity instance is managed, use {@link #contains}.
     */
    @Deprecated boolean isManaged();

    /**
     * Whether to check for a global transaction upon every managed,
     * non-transactional operation. Defaults to false.
     */
    boolean getSyncWithManagedTransactions();

    /**
     * Whether to check for a global transaction upon every managed,
     * non-transactional operation. Defaults to false.
     */
    void setSyncWithManagedTransactions(boolean resync);

    /**
     * Return the current thread's class loader at the time this entity
     * manager was obtained from the factory.
     */
    ClassLoader getClassLoader();

    /**
     * Return the connection user name.
     */
    String getConnectionUserName();

    /**
     * Return the connection password.
     */
    String getConnectionPassword();

    /**
     * Whether the entity manager or its managed instances are used in a
     * multithreaded environment.
     */
    boolean getMultithreaded();

    /**
     * Whether the entity manager or its managed instances are used in a
     * multithreaded environment.
     */
    void setMultithreaded(boolean multi);

    /**
     * Whether to take into account changes in the transaction when executing
     * a query or iterating an extent.
     */
    boolean getIgnoreChanges();

    /**
     * Whether to take into account changes in the transaction when executing
     * a query or iterating an extent.
     */
    void setIgnoreChanges(boolean ignore);

    /**
     * Whether to allow nontransactional access to persistent state.
     */
    boolean getNontransactionalRead();

    /**
     * Whether to allow nontransactional access to persistent state.
     */
    void setNontransactionalRead(boolean read);

    /**
     * Whether to allow nontransactional changes to persistent state.
     */
    boolean getNontransactionalWrite();

    /**
     * Whether to allow nontransactional changes to persistent state.
     */
    void setNontransactionalWrite(boolean write);

    /**
     * Whether to use optimistic transactional semantics.
     */
    boolean getOptimistic();

    /**
     * Whether to use optimistic transactional semantics.
     */
    void setOptimistic(boolean opt);

    /**
     * Whether to restore an object's original state on rollback.
     */
    RestoreStateType getRestoreState();

    /**
     * Whether to restore an object's original state on rollback.
     */
    void setRestoreState(RestoreStateType restoreType);

    /**
     * Whether objects retain their persistent state on transaction commit.
     */
    boolean getRetainState();

    /**
     * Whether objects retain their persistent state on transaction commit.
     */
    void setRetainState(boolean retain);

    /**
     * Detach mode constant to determine which fields are part of the
     * detached graph.
     */
    DetachStateType getDetachState();

    /**
     * Detach mode constant to determine which fields are part of the
     * detached graph.
     */
    void setDetachState(DetachStateType type);

    /**
     * Whether to clear state when entering a transaction.
     */
    AutoClearType getAutoClear();

    /**
     * Whether to clear state when entering a transaction.
     */
    void setAutoClear(AutoClearType clearType);

    /**
     * {@link AutoDetachType} values which indicate when persistent
     * managed objects should be automatically detached in-place.
     */
    EnumSet<AutoDetachType> getAutoDetach();

    /**
     * {@link AutoDetachType} values which indicate when persistent
     * managed objects should be automatically detached in-place.
     * The current value is replaced in its entirety.
     */
    void setAutoDetach(AutoDetachType value);

    /**
     * {@link AutoDetachType} values which indicate when persistent
     * managed objects should be automatically detached in-place.
     * The current value is replaced in its entirety.
     */
    void setAutoDetach(EnumSet<AutoDetachType> values);

    /**
     * Bit flags marked in {@link AutoDetachType} which indicate when persistent
     * managed objects should be automatically detached in-place.
     *
     * @since 1.1.0
     */
    void setAutoDetach(AutoDetachType value, boolean on);

    /**
     * Whether to also evict an object from the store cache when it is
     * evicted through this entity manager.
     */
    boolean getEvictFromStoreCache();

    /**
     * Whether to also evict an object from the store cache when it is
     * evicted through this entity manager.
     */
    void setEvictFromStoreCache(boolean evict);

    /**
     * Whether objects accessed during this transaction will be added to the
     * store cache. Defaults to true.
     *
     * @since 0.3.4
     */
    boolean getPopulateStoreCache();

    /**
     * Whether to populate the store cache with objects used by this
     * transaction. Defaults to true.
     *
     * @since 0.3.4
     */
    void setPopulateStoreCache(boolean cache);

    /**
     * Whether memory usage is reduced during this transaction at the expense
     * of tracking changes at the type level instead of the instance level,
     * resulting in more aggressive cache invalidation.
     *
     * @since 1.0.0
     */
    boolean isTrackChangesByType();

    /**
     * If a large number of objects will be created, modified, or deleted
     * during this transaction setting this option to true will reduce memory
     * usage if you perform periodic flushes by tracking changes at the type
     * level instead of the instance level, resulting in more aggressive cache
     * invalidation.
     *
     * @since 1.0.0
     */
    void setTrackChangesByType(boolean track);

    /**
     * Put the specified key-value pair into the map of user objects. Use
     * a value of null to remove the key.
     */
    Object putUserObject(Object key, Object val);

    /**
     * Get the value for the specified key from the map of user objects.
     */
    Object getUserObject(Object key);

    ///////////
    // Lookups
    ///////////

    /**
     * Return the objects with the given oids.
     *
     * @param oids the oids of the objects to return
     * @return the objects that were looked up, in the
     * same order as the oids parameter.
     * @see #find(Class,Object)
     */
    <T> T[] findAll(Class<T> cls, Object... oids);

    /**
     * Return the objects with the given oids.
     *
     * @param oids the oids of the objects to return
     * @return the objects that were looked up, in the
     * same order as the oids parameter.
     * @see #find(Class,Object)
     */
    <T> Collection<T> findAll(Class<T> cls, Collection oids);

    /**
     * Return the cached instance for the given oid/object, or null if not
     * cached.
     *
     * @param oid the object's id
     * @return the cached object, or null if not cached
     */
    <T> T findCached(Class<T> cls, Object oid);

    /**
     * Return the application identity class the given persistent class uses
     * for object ids, or null if not a type that uses application identity.
     */
    Class getObjectIdClass(Class pcClass);

    ////////////////
    // Transactions
    ////////////////

    @Override OpenJPAEntityTransaction getTransaction();

    /**
     * Set a transactional savepoint where operations after this savepoint
     * will be rolled back.
     */
    void setSavepoint(String name);

    /**
     * Rollback the current transaction to the last savepoint.
     * Savepoints set after this one will become invalid.
     */
    void rollbackToSavepoint();

    /**
     * Rollback the current transaction to the given savepoint name.
     * Savepoints set after this one will become invalid.
     */
    void rollbackToSavepoint(String name);

    /**
     * Release the last set savepoint and any resources associated with it.
     * The given savepoint and any set after it will become invalid.
     */
    void releaseSavepoint();

    /**
     * Release the savepoint and any resources associated with it.
     * The given savepoint and any set after it will become invalid.
     */
    void releaseSavepoint(String name);

    /**
     * Run pre-flush actions on transactional objects, including
     * persistence-by-reachability, inverse relationship management,
     * deletion of dependent instances, and instance callbacks.
     * Transaction listeners are not invoked.
     *
     * @since 0.3.3
     */
    void preFlush();

    /**
     * Validate the changes made in this transaction, reporting any optimistic
     * violations, constraint violations, etc. In a datastore transaction or
     * a flushed optimistic transaction, this method will act just like
     * {@link #flush()}. In an optimistic transaction that has not yet begun a
     * datastore-level transaction, however, it will only report exceptions
     * that would occur on flush, without retaining any datastore resources.
     */
    void validateChanges();

    /**
     * Whether a store transaction is active.
     */
    boolean isStoreActive();

    /**
     * Begins a store transaction if one isn't already started. The
     * entity manager must already be in a logical transaction.
     */
    void beginStore();

    ////////////////////
    // Object Lifecycle
    ////////////////////

    /**
     * Whether the given objects are managed.
     */
    boolean containsAll(Object... pcs);

    /**
     * Whether the given objects are managed.
     */
    boolean containsAll(Collection pcs);

    /**
     * Persist the given objects.
     */
    void persistAll(Object... pcs);

    /**
     * Persist the given objects.
     */
    void persistAll(Collection pcs);

    /**
     * Delete the given persistent objects.
     */
    void removeAll(Object... pcs);

    /**
     * Delete the given persistent objects.
     */
    void removeAll(Collection pcs);

    /**
     * Release the given object from management. This operation is not
     * recursive.
     */
    void release(Object pc);

    /**
     * Release the given object from management. This operation is not
     * recursive.
     */
    void releaseAll(Object... pcs);

    /**
     * Release the given objects from management. This operation is not
     * recursive.
     */
    void releaseAll(Collection pcs);

    /**
     * Immediately load the given object's persistent fields. One might
     * use this action to make sure that an instance's fields are loaded
     * before transitioning it to transient. Note that this action is not
     * recursive. Any related objects that are loaded will not necessarily
     * have their fields loaded.
     */
    void retrieve(Object pc);

    /**
     * Retrieve the persistent state of the given objects.
     *
     * @see #retrieve
     */
    void retrieveAll(Object... pcs);

    /**
     * Retrieve the persistent state of the given objects.
     *
     * @see #retrieve
     */
    void retrieveAll(Collection pcs);

    /**
     * Refresh the state of the given objects.
     */
    void refreshAll(Object... pcs);

    /**
     * Refresh the state of the given objects.
     */
    void refreshAll(Collection pcs);

    /**
     * Refresh all transactional objects.
     */
    void refreshAll();

    /**
     * <P> Evict the given object.</P>
     * <P> Eviction acts as a hint to the persistence provider, and indicates that the persistent object is no longer
     * needed by the application and may be garbage collected. It does not remove the object from the L1 cache and only
     * affects objects which are managed and unmodified.
     * </P>
     * @param pc A persistent class which will be evicted
     */
    void evict(Object pc);

    /**
     * <P>Evict the given objects.</P>
     * <P> Eviction acts as a hint to the persistence provider, and indicates that the persistent object is no longer
     * needed by the application and may be garbage collected. It does not remove the object from the L1 cache and only
     * affects objects which are managed and unmodified.
     * </P>
     * @param pcs The persistent classes which will be evicted
     */
    void evictAll(Object... pcs);

    /**
     * <P>Evict the given objects.</P>
     * <P> Eviction acts as a hint to the persistence provider, and indicates that the persistent object is no longer
     * needed by the application and may be garbage collected. It does not remove the object from the L1 cache and only
     * affects objects which are managed and unmodified.
     * </P>
     * @param pcs A collection of persistent classes which will be evicted.
     */
    void evictAll(Collection pcs);

    /**
     * <P>Evict all clean objects.</P>
     * <P> Eviction acts as a hint to the persistence provider, and indicates that the persistent object is no longer
     * needed by the application and may be garbage collected. It does not remove the object from the L1 cache and only
     * affects objects which are managed and unmodified.
     * </P>
     */
    void evictAll();

    /**
     * <P>Evict all persistent-clean and persistent-nontransactional
     * instances in the extent of the given class (including subclasses).</P>
     * <P> Eviction acts as a hint to the persistence provider, and indicates that the persistent object is no longer
     * needed by the application and may be garbage collected. It does not remove the object from the L1 cache and only
     * affects objects which are managed and unmodified.
     * </P>
     * @param cls All clean instances of this class will be evicted.
     */
    void evictAll(Class cls);

    /**
     * <P>Evict all persistent-clean and persistent-nontransactional
     * instances in the given {@link Extent}.</P>
     * <P> Eviction acts as a hint to the persistence provider, and indicates that the persistent object is no longer
     * needed by the application and may be garbage collected. It does not remove the object from the L1 cache and only
     * affects objects which are managed and unmodified.
     * </P>
     * @param extent Extend which contains the persistent classes to evict.
     */
    void evictAll(Extent extent);

    /**
     * Detach the specified object from the entity manager, detaching based on
     * the AutoDetach value specified and returning a copy of the detached
     * entity.
     *
     * @param pc the instance to detach
     * @return the detached instance
     *
     * @since 2.0.0
     *
     * Note: This method provides the same contract as the detach method with
     * signature: public <T> T detach(T pc) available in the 1.x release of
     * OpenJPA. The JPA 2.0 specification defined a method with an incompatible
     * signature and different semantics.  The specification defined method
     * trumped the existing method.
     */
    <T> T detachCopy(T pc);

    /**
     * Detach the specified objects from the entity manager.
     *
     * @param pcs the instances to detach
     * @return the detached instances
     */
    Collection detachAll(Collection pcs);

    /**
     * Detach the specified objects from the entity manager.
     *
     * @param pcs the instances to detach
     * @return the detached instances
     */
    Object[] detachAll(Object... pcs);

    /**
     * Merge the specified objects into the entity manager.
     *
     * @param pcs instances to import
     * @return the re-attached instances
     */
    Object[] mergeAll(Object... pcs);

    /**
     * Merge the specified detached objects into the entity manager.
     *
     * @param pcs Collection of instances to import
     * @return the re-attached instances
     */
    Collection mergeAll(Collection pcs);

    /**
     * Make the given object transactional.
     *
     * @param pc instance to make transactional
     * @param updateVersion if true, the instance's version will be
     * incremented at the next flush
     */
    void transactional(Object pc, boolean updateVersion);

    /**
     * Make the given objects transactional.
     *
     * @param objs instances to make transactional
     * @param updateVersion if true, the instance's version will be
     * incremented at the next flush
     */
    void transactionalAll(Collection objs, boolean updateVersion);

    /**
     * Make the given objects transactional.
     *
     * @param objs instances to make transactional
     * @param updateVersion if true, the instance's version will be
     * incremented at the next flush
     */
    void transactionalAll(Object[] objs, boolean updateVersion);

    /**
     * Make the given object nontransactional.
     */
    void nontransactional(Object pc);

    /**
     * Make the given objects nontransactional.
     */
    void nontransactionalAll(Collection objs);

    /**
     * Make the given objects nontransactional.
     */
    void nontransactionalAll(Object[] objs);

    ////////////////////////////
    // Extent, Query, Generator
    ////////////////////////////

    /**
     * Return the named generator defined in the metadata.
     */
    Generator getNamedGenerator(String name);

    /**
     * Returns a {@link Generator} for the datastore identity values of the
     * specified type, or null if the type is unmanaged or its identity
     * cannot be represented by a sequence.
     */
    Generator getIdGenerator(Class forClass);

    /**
     * Returns a {@link Generator} for the generated values of the specified
     * type, or null if the field is not generated.
     */
    Generator getFieldGenerator(Class forClass, String fieldName);

    /**
     * Return an extent of the given class, optionally including subclasses.
     */
    <T> Extent<T> createExtent(Class<T> cls, boolean subs);

    @Override OpenJPAQuery createQuery(String query);

    @Override OpenJPAQuery createNamedQuery(String name);

    @Override OpenJPAQuery createNativeQuery(String sql);

    @Override OpenJPAQuery createNativeQuery(String sql, Class resultClass);

    @Override OpenJPAQuery createNativeQuery(String sql, String resultMapping);

    /**
     * Create a new query from the given one.
     */
    OpenJPAQuery createQuery(Query query);

    /**
     * Create a new query in the given language.
     */
    OpenJPAQuery createQuery(String language, String query);

    /**
     * Create an executable query from a dynamically defined query.
     *
     * @since 2.0.0
     */
    OpenJPAQuery createDynamicQuery(QueryDefinition dynamic);

    ///////////
    // Locking
    ///////////

    /**
     * Return the lock mode of the given instance, or null if not locked.
     */
    @Override LockModeType getLockMode(Object pc);

    /**
     * Ensure that the given instance is locked at the given lock level.
     *
     * @param pc the object to lock
     * @param mode the lock level to use
     * @param timeout the number of milliseconds to wait for the lock before
     * giving up, or -1 for no limit
     */
    void lock(Object pc, LockModeType mode, int timeout);

    /**
     * Ensure that the given instance is locked at the current lock level, as
     * set in the {@link FetchPlan} for the entity manager.
     */
    void lock(Object pc);

    /**
     * Ensure that the given instances are locked at the given lock level.
     *
     * @param pcs the objects to lock
     * @param mode the lock level to use
     * @param timeout the number of milliseconds to wait for the lock before
     * giving up, or -1 for no limit
     */
    void lockAll(Collection pcs, LockModeType mode, int timeout);

    /**
     * Ensure that the given instances are locked at the current lock level,
     * as set in the {@link FetchPlan} for the entity manager.
     */
    void lockAll(Collection pcs);

    /**
     * Ensure that the given instances are locked at the given lock level.
     *
     * @param pcs the objects to lock
     * @param mode the lock level to use
     * @param timeout the number of milliseconds to wait for the lock before
     * giving up, or -1 for no limit
     */
    void lockAll(Object[] pcs, LockModeType mode, int timeout);

    /**
     * Ensure that the given instances are locked at the current lock level,
     * as set in the {@link FetchPlan} for the entity manager.
     */
    void lockAll(Object... pcs);

    //////////////
    // Connection
    //////////////

    /**
     * Cancel all pending data store statements. If statements are cancelled
     * while a flush is in progress, the transaction rollback only flag will
     * be set.
     *
     * @return true if any statements were cancelled, false otherwise
     */
    boolean cancelAll();

    /**
     * Return the connection in use by the entity manager, or a new
     * connection if none.
     */
    Object getConnection();

    /////////
    // Cache
    /////////

    /**
     * Return a set of all managed instances.
     */
    Collection getManagedObjects();

    /**
     * Return a set of current transaction instances.
     */
    Collection getTransactionalObjects();

    /**
     * Return a set of instances which will become transactional upon
     * the next transaction.
     */
    Collection getPendingTransactionalObjects();

    /**
     * Return a set of current dirty instances.
     */
    Collection getDirtyObjects();

    /**
     * Whether dirty objects will be returned in the order they were dirtied.
     * Default is determined by the store manager.
     */
    boolean getOrderDirtyObjects();

    /**
     * Whether dirty objects will be returned in the order they were dirtied.
     * Default is determined by the store manager.
     */
    void setOrderDirtyObjects(boolean order);

    /**
     * Mark the given class as dirty within the current transaction.
     */
    void dirtyClass(Class cls);

    /**
     * Return the set of classes that have been made persistent in the current
     * transaction.
     */
    Collection<Class> getPersistedClasses();

    /**
     * Return the set of classes that have been deleted in the current
     * transaction.
     */
    Collection<Class> getRemovedClasses();

    /**
     * Return the set of classes for objects that have been modified
     * in the current transaction.
     */
    Collection<Class> getUpdatedClasses();

    /**
     * Create a new instance of type <code>cls</code>. If <code>cls</code> is
     * an interface or an abstract class whose abstract methods follow the
     * JavaBeans convention, this method will create a concrete implementation
     * according to the metadata that defines the class. If <code>cls</code>
     * is a non-final concrete type that has metadata but does not implement
     * {@link org.apache.openjpa.enhance.PersistenceCapable}, this method will
     * create a subclass of the type that does implement
     * {@link org.apache.openjpa.enhance.PersistenceCapable}, and will attempt
     * to redefine the methods in <code>cls</code> to enable persistent
     * attribute tracking. Otherwise, if <code>cls</code> is a managed type,
     * this will return an instance of the specified class.
     *
     * @throws IllegalArgumentException if <code>cls</code> is not a managed
     * type or interface.
     */
    <T> T createInstance(Class<T> cls);

    /**
     * Make the named field of the given object dirty.
     */
    void dirty(Object o, String field);

    /**
     * Return the oid of the given instance.
     */
    Object getObjectId(Object o);

    /**
     * Return whether the given object is dirty.
     */
    boolean isDirty(Object o);

    /**
     * Return whether the given object is transactional.
     */
    boolean isTransactional(Object o);

    /**
     * Return whether the given object is persistent.
     */
    boolean isPersistent(Object o);

    /**
     * Return whether the given object was made persistent in the current
     * transaction.
     */
    boolean isNewlyPersistent(Object o);

    /**
     * Return whether the given object is deleted.
     */
    boolean isRemoved(Object o);

    /**
     * Returns <code>true</code> if <code>pc</code> is a detached object
	 * (one that can be reattached to a {@link EntityManager} via a call
	 * to {@link EntityManager#merge}); otherwise returns
	 * <code>false</code>.
	 */
	boolean isDetached (Object o);

	/**
	 * Returns the current version indicator for <code>o</code>.
	 */
	Object getVersion (Object o);

    /**
     * @deprecated use the {@link ConnectionRetainMode} enum instead.
     */
    @Deprecated int CONN_RETAIN_DEMAND =
        ConnectionRetainModes.CONN_RETAIN_DEMAND;

    /**
     * @deprecated use the {@link ConnectionRetainMode} enum instead.
     */
    @Deprecated int CONN_RETAIN_TRANS =
        ConnectionRetainModes.CONN_RETAIN_TRANS;

    /**
     * @deprecated use the {@link ConnectionRetainMode} enum instead.
     */
    @Deprecated int CONN_RETAIN_ALWAYS =
        ConnectionRetainModes.CONN_RETAIN_ALWAYS;

    /**
     * @deprecated use the {@link DetachStateType} enum instead.
     */
    @Deprecated int DETACH_FETCH_GROUPS =
        DetachState.DETACH_FETCH_GROUPS;

    /**
     * @deprecated use the {@link DetachStateType} enum instead.
     */
    @Deprecated int DETACH_FGS = DetachState.DETACH_FGS;

    /**
     * @deprecated use the {@link DetachStateType} enum instead.
     */
    @Deprecated int DETACH_LOADED = DetachState.DETACH_LOADED;

    /**
     * @deprecated use the {@link DetachStateType} enum instead.
     */
    @Deprecated int DETACH_ALL = DetachState.DETACH_ALL;

    /**
     * @deprecated use the {@link RestoreStateType} enum instead.
     */
    @Deprecated int RESTORE_NONE = RestoreState.RESTORE_NONE;

    /**
     * @deprecated use the {@link RestoreStateType} enum instead.
     */
    @Deprecated int RESTORE_IMMUTABLE = RestoreState.RESTORE_IMMUTABLE;

    /**
     * @deprecated use the {@link RestoreStateType} enum instead.
     */
    @Deprecated int RESTORE_ALL = RestoreState.RESTORE_ALL;

    /**
     * @deprecated use the {@link AutoDetachType} enum instead.
     */
    @Deprecated int DETACH_CLOSE = AutoDetach.DETACH_CLOSE;

    /**
     * @deprecated use the {@link AutoDetachType} enum instead.
     */
    @Deprecated int DETACH_COMMIT = AutoDetach.DETACH_COMMIT;

    /**
     * @deprecated use the {@link AutoDetachType} enum instead.
     */
    @Deprecated int DETACH_NONTXREAD = AutoDetach.DETACH_NONTXREAD;

    /**
     * @deprecated use the {@link AutoDetachType} enum instead.
     */
    @Deprecated int DETACH_ROLLBACK = AutoDetach.DETACH_ROLLBACK;

    /**
     * @deprecated use the {@link AutoClearType} enum instead.
     */
    @Deprecated int CLEAR_DATASTORE = AutoClear.CLEAR_DATASTORE;

    /**
     * @deprecated use the {@link AutoClearType} enum instead.
     */
    @Deprecated int CLEAR_ALL = AutoClear.CLEAR_ALL;

    /**
     * @deprecated use the {@link CallbackMode} enum instead.
     */
    @Deprecated int CALLBACK_FAIL_FAST =
        CallbackModes.CALLBACK_FAIL_FAST;

    /**
     * @deprecated use the {@link CallbackMode} enum instead.
     */
    @Deprecated int CALLBACK_IGNORE = CallbackModes.CALLBACK_IGNORE;

    /**
     * @deprecated use the {@link CallbackMode} enum instead.
     */
    @Deprecated int CALLBACK_LOG = CallbackModes.CALLBACK_LOG;

    /**
     * @deprecated use the {@link CallbackMode} enum instead.
     */
    @Deprecated int CALLBACK_RETHROW = CallbackModes.CALLBACK_RETHROW;

    /**
     * @deprecated use the {@link CallbackMode} enum instead.
     */
    @Deprecated int CALLBACK_ROLLBACK = CallbackModes.CALLBACK_ROLLBACK;

    /**
     * @deprecated cast to {@link OpenJPAEntityManagerSPI} instead. This
     * method pierces the published-API boundary, as does the SPI cast.
     */
    @Deprecated org.apache.openjpa.conf.OpenJPAConfiguration getConfiguration();

    /**
     * @deprecated use {@link #setRestoreState(RestoreStateType)} instead.
     */
    @Deprecated void setRestoreState(int restore);

    /**
     * @deprecated use {@link #setDetachState(DetachStateType)} instead.
     */
    @Deprecated void setDetachState(int detach);

    /**
     * @deprecated use {@link #setAutoClear(AutoClearType)} instead.
     */
    @Deprecated void setAutoClear(int autoClear);

    /**
     * @deprecated use {@link #setAutoDetach(AutoDetachType)} or
     * {@link #setAutoDetach(java.util.EnumSet)} instead.
     */
    @Deprecated void setAutoDetach(int autoDetachFlags);

    /**
     * @deprecated use {@link #setAutoDetach(AutoDetachType, boolean)} instead.
     */
    @Deprecated void setAutoDetach(int flag, boolean on);

    /**
     * @deprecated use {@link #isTrackChangesByType()} instead.
     */
    @Deprecated boolean isLargeTransaction();

    /**
     * @deprecated use {@link #setTrackChangesByType(boolean)} instead.
     */
    @Deprecated void setLargeTransaction(boolean value);

    /**
     * @deprecated cast to {@link OpenJPAEntityManagerSPI} instead. This
     * method pierces the published-API boundary, as does the SPI cast.
     */
    @Deprecated void addTransactionListener(Object listener);

    /**
     * @deprecated cast to {@link OpenJPAEntityManagerSPI} instead. This
     * method pierces the published-API boundary, as does the SPI cast.
     */
    @Deprecated void removeTransactionListener(Object listener);

    /**
     * @deprecated cast to {@link OpenJPAEntityManagerSPI} instead. This
     * method pierces the published-API boundary, as does the SPI cast.
     */
    @Deprecated int getTransactionListenerCallbackMode();

    /**
     * @deprecated cast to {@link OpenJPAEntityManagerSPI} instead. This
     * method pierces the published-API boundary, as does the SPI cast.
     */
