Index: java/javax/jdo/annotations/PreDelete.java
===================================================================
--- java/javax/jdo/annotations/PreDelete.java	(revision 0)
+++ java/javax/jdo/annotations/PreDelete.java	(revision 0)
@@ -0,0 +1,41 @@
+package javax.jdo.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for a method on a persistence capable object to be used just as
+ * {@link javax.jdo.listener.DeleteCallback#jdoPreDelete()}.
+ * 
+ * @see javax.jdo.listener.DeleteCallback#jdoPreDelete()
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PreDelete {
+	/**
+	 * The order of execution of this method relative to other annotated
+	 * callback methods. A lower order value means that the annotated method has
+	 * a higher precedence among annotated methods, and a higher order, a lower
+	 * precedence. Order values need not be contiguous among annotated methods.
+	 * Methods that are implementations of the corresponding callback interface
+	 * method are always called first. The order value {@link Integer#MAX_VALUE}
+	 * , the default, signifies that the order is undefined among annotated
+	 * methods. If other annotated methods define an order, those methods will
+	 * be called before annotated methods with an undefined order. If other
+	 * annotated methods define equal order values, then methods annotated with
+	 * lower order values will be called before them, the methods with equal
+	 * order values will be called in an undefined order, and then any methods
+	 * with higher order values will be called after the methods with equal
+	 * order values have been called. If a method that represents an
+	 * implementation of the corresponding interface method carries this
+	 * annotation, the annotation and its order are ignored, and the interface
+	 * method is called first. If a subclass annotates a method with the same
+	 * order as an annotated method in its superclass hierarchy, then the
+	 * subclass's method is called first, otherwise the order values among all
+	 * annotated methods in the class and its superclass hierarchy determine
+	 * call order.
+	 */
+	int order() default Integer.MAX_VALUE;
+}
Index: java/javax/jdo/annotations/PostAttach.java
===================================================================
--- java/javax/jdo/annotations/PostAttach.java	(revision 0)
+++ java/javax/jdo/annotations/PostAttach.java	(revision 0)
@@ -0,0 +1,41 @@
+package javax.jdo.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for a method on a persistence capable object to be used just as
+ * {@link javax.jdo.listener.AttachCallback#jdoPostAttach()}.
+ * 
+ * @see javax.jdo.listener.AttachCallback#jdoPostAttach()
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PostAttach {
+	/**
+	 * The order of execution of this method relative to other annotated
+	 * callback methods. A lower order value means that the annotated method has
+	 * a higher precedence among annotated methods, and a higher order, a lower
+	 * precedence. Order values need not be contiguous among annotated methods.
+	 * Methods that are implementations of the corresponding callback interface
+	 * method are always called first. The order value {@link Integer#MAX_VALUE}
+	 * , the default, signifies that the order is undefined among annotated
+	 * methods. If other annotated methods define an order, those methods will
+	 * be called before annotated methods with an undefined order. If other
+	 * annotated methods define equal order values, then methods annotated with
+	 * lower order values will be called before them, the methods with equal
+	 * order values will be called in an undefined order, and then any methods
+	 * with higher order values will be called after the methods with equal
+	 * order values have been called. If a method that represents an
+	 * implementation of the corresponding interface method carries this
+	 * annotation, the annotation and its order are ignored, and the interface
+	 * method is called first. If a subclass annotates a method with the same
+	 * order as an annotated method in its superclass hierarchy, then the
+	 * subclass's method is called first, otherwise the order values among all
+	 * annotated methods in the class and its superclass hierarchy determine
+	 * call order.
+	 */
+	int order() default Integer.MAX_VALUE;
+}
Index: java/javax/jdo/annotations/PreAttach.java
===================================================================
--- java/javax/jdo/annotations/PreAttach.java	(revision 0)
+++ java/javax/jdo/annotations/PreAttach.java	(revision 0)
@@ -0,0 +1,41 @@
+package javax.jdo.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for a method on a persistence capable object to be used just as
+ * {@link javax.jdo.listener.AttachCallback#jdoPreAttach()}.
+ * 
+ * @see javax.jdo.listener.AttachCallback#jdoPreAttach()
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PreAttach {
+	/**
+	 * The order of execution of this method relative to other annotated
+	 * callback methods. A lower order value means that the annotated method has
+	 * a higher precedence among annotated methods, and a higher order, a lower
+	 * precedence. Order values need not be contiguous among annotated methods.
+	 * Methods that are implementations of the corresponding callback interface
+	 * method are always called first. The order value {@link Integer#MAX_VALUE}
+	 * , the default, signifies that the order is undefined among annotated
+	 * methods. If other annotated methods define an order, those methods will
+	 * be called before annotated methods with an undefined order. If other
+	 * annotated methods define equal order values, then methods annotated with
+	 * lower order values will be called before them, the methods with equal
+	 * order values will be called in an undefined order, and then any methods
+	 * with higher order values will be called after the methods with equal
+	 * order values have been called. If a method that represents an
+	 * implementation of the corresponding interface method carries this
+	 * annotation, the annotation and its order are ignored, and the interface
+	 * method is called first. If a subclass annotates a method with the same
+	 * order as an annotated method in its superclass hierarchy, then the
+	 * subclass's method is called first, otherwise the order values among all
+	 * annotated methods in the class and its superclass hierarchy determine
+	 * call order.
+	 */
+	int order() default Integer.MAX_VALUE;
+}
Index: java/javax/jdo/annotations/PreClear.java
===================================================================
--- java/javax/jdo/annotations/PreClear.java	(revision 0)
+++ java/javax/jdo/annotations/PreClear.java	(revision 0)
@@ -0,0 +1,41 @@
+package javax.jdo.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for a method on a persistence capable object to be used just as
+ * {@link javax.jdo.listener.ClearCallback#jdoPreClear()}.
+ * 
+ * @see javax.jdo.listener.ClearCallback#jdoPreClear()
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PreClear {
+	/**
+	 * The order of execution of this method relative to other annotated
+	 * callback methods. A lower order value means that the annotated method has
+	 * a higher precedence among annotated methods, and a higher order, a lower
+	 * precedence. Order values need not be contiguous among annotated methods.
+	 * Methods that are implementations of the corresponding callback interface
+	 * method are always called first. The order value {@link Integer#MAX_VALUE}
+	 * , the default, signifies that the order is undefined among annotated
+	 * methods. If other annotated methods define an order, those methods will
+	 * be called before annotated methods with an undefined order. If other
+	 * annotated methods define equal order values, then methods annotated with
+	 * lower order values will be called before them, the methods with equal
+	 * order values will be called in an undefined order, and then any methods
+	 * with higher order values will be called after the methods with equal
+	 * order values have been called. If a method that represents an
+	 * implementation of the corresponding interface method carries this
+	 * annotation, the annotation and its order are ignored, and the interface
+	 * method is called first. If a subclass annotates a method with the same
+	 * order as an annotated method in its superclass hierarchy, then the
+	 * subclass's method is called first, otherwise the order values among all
+	 * annotated methods in the class and its superclass hierarchy determine
+	 * call order.
+	 */
+	int order() default Integer.MAX_VALUE;
+}
Index: java/javax/jdo/annotations/PostDetach.java
===================================================================
--- java/javax/jdo/annotations/PostDetach.java	(revision 0)
+++ java/javax/jdo/annotations/PostDetach.java	(revision 0)
@@ -0,0 +1,41 @@
+package javax.jdo.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for a method on a persistence capable object to be used just as
+ * {@link javax.jdo.listener.AttachCallback#jdoPostDetach()}.
+ * 
+ * @see javax.jdo.listener.DetachCallback#jdoPostDetach()
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PostDetach {
+	/**
+	 * The order of execution of this method relative to other annotated
+	 * callback methods. A lower order value means that the annotated method has
+	 * a higher precedence among annotated methods, and a higher order, a lower
+	 * precedence. Order values need not be contiguous among annotated methods.
+	 * Methods that are implementations of the corresponding callback interface
+	 * method are always called first. The order value {@link Integer#MAX_VALUE}
+	 * , the default, signifies that the order is undefined among annotated
+	 * methods. If other annotated methods define an order, those methods will
+	 * be called before annotated methods with an undefined order. If other
+	 * annotated methods define equal order values, then methods annotated with
+	 * lower order values will be called before them, the methods with equal
+	 * order values will be called in an undefined order, and then any methods
+	 * with higher order values will be called after the methods with equal
+	 * order values have been called. If a method that represents an
+	 * implementation of the corresponding interface method carries this
+	 * annotation, the annotation and its order are ignored, and the interface
+	 * method is called first. If a subclass annotates a method with the same
+	 * order as an annotated method in its superclass hierarchy, then the
+	 * subclass's method is called first, otherwise the order values among all
+	 * annotated methods in the class and its superclass hierarchy determine
+	 * call order.
+	 */
+	int order() default Integer.MAX_VALUE;
+}
Index: java/javax/jdo/annotations/PreDetach.java
===================================================================
--- java/javax/jdo/annotations/PreDetach.java	(revision 0)
+++ java/javax/jdo/annotations/PreDetach.java	(revision 0)
@@ -0,0 +1,41 @@
+package javax.jdo.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for a method on a persistence capable object to be used just as
+ * {@link javax.jdo.listener.DetachCallback#jdoPreDetach()}.
+ * 
+ * @see javax.jdo.listener.DetachCallback#jdoPreDetach()
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PreDetach {
+	/**
+	 * The order of execution of this method relative to other annotated
+	 * callback methods. A lower order value means that the annotated method has
+	 * a higher precedence among annotated methods, and a higher order, a lower
+	 * precedence. Order values need not be contiguous among annotated methods.
+	 * Methods that are implementations of the corresponding callback interface
+	 * method are always called first. The order value {@link Integer#MAX_VALUE}
+	 * , the default, signifies that the order is undefined among annotated
+	 * methods. If other annotated methods define an order, those methods will
+	 * be called before annotated methods with an undefined order. If other
+	 * annotated methods define equal order values, then methods annotated with
+	 * lower order values will be called before them, the methods with equal
+	 * order values will be called in an undefined order, and then any methods
+	 * with higher order values will be called after the methods with equal
+	 * order values have been called. If a method that represents an
+	 * implementation of the corresponding interface method carries this
+	 * annotation, the annotation and its order are ignored, and the interface
+	 * method is called first. If a subclass annotates a method with the same
+	 * order as an annotated method in its superclass hierarchy, then the
+	 * subclass's method is called first, otherwise the order values among all
+	 * annotated methods in the class and its superclass hierarchy determine
+	 * call order.
+	 */
+	int order() default Integer.MAX_VALUE;
+}
Index: java/javax/jdo/annotations/PreStore.java
===================================================================
--- java/javax/jdo/annotations/PreStore.java	(revision 0)
+++ java/javax/jdo/annotations/PreStore.java	(revision 0)
@@ -0,0 +1,41 @@
+package javax.jdo.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for a method on a persistence capable object to be used just as
+ * {@link javax.jdo.listener.StoreCallback#jdoPreStore()}.
+ * 
+ * @see javax.jdo.listener.StoreCallback#jdoPreStore()
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PreStore {
+	/**
+	 * The order of execution of this method relative to other annotated
+	 * callback methods. A lower order value means that the annotated method has
+	 * a higher precedence among annotated methods, and a higher order, a lower
+	 * precedence. Order values need not be contiguous among annotated methods.
+	 * Methods that are implementations of the corresponding callback interface
+	 * method are always called first. The order value {@link Integer#MAX_VALUE}
+	 * , the default, signifies that the order is undefined among annotated
+	 * methods. If other annotated methods define an order, those methods will
+	 * be called before annotated methods with an undefined order. If other
+	 * annotated methods define equal order values, then methods annotated with
+	 * lower order values will be called before them, the methods with equal
+	 * order values will be called in an undefined order, and then any methods
+	 * with higher order values will be called after the methods with equal
+	 * order values have been called. If a method that represents an
+	 * implementation of the corresponding interface method carries this
+	 * annotation, the annotation and its order are ignored, and the interface
+	 * method is called first. If a subclass annotates a method with the same
+	 * order as an annotated method in its superclass hierarchy, then the
+	 * subclass's method is called first, otherwise the order values among all
+	 * annotated methods in the class and its superclass hierarchy determine
+	 * call order.
+	 */
+	int order() default Integer.MAX_VALUE;
+}
Index: java/javax/jdo/annotations/PostLoad.java
===================================================================
--- java/javax/jdo/annotations/PostLoad.java	(revision 0)
+++ java/javax/jdo/annotations/PostLoad.java	(revision 0)
@@ -0,0 +1,41 @@
+package javax.jdo.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for a method on a persistence capable object to be used just as
+ * {@link javax.jdo.listener.LoadCallback#jdoPostLoad()}.
+ * 
+ * @see javax.jdo.listener.LoadCallback#jdoPostLoad()
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PostLoad {
+	/**
+	 * The order of execution of this method relative to other annotated
+	 * callback methods. A lower order value means that the annotated method has
+	 * a higher precedence among annotated methods, and a higher order, a lower
+	 * precedence. Order values need not be contiguous among annotated methods.
+	 * Methods that are implementations of the corresponding callback interface
+	 * method are always called first. The order value {@link Integer#MAX_VALUE}
+	 * , the default, signifies that the order is undefined among annotated
+	 * methods. If other annotated methods define an order, those methods will
+	 * be called before annotated methods with an undefined order. If other
+	 * annotated methods define equal order values, then methods annotated with
+	 * lower order values will be called before them, the methods with equal
+	 * order values will be called in an undefined order, and then any methods
+	 * with higher order values will be called after the methods with equal
+	 * order values have been called. If a method that represents an
+	 * implementation of the corresponding interface method carries this
+	 * annotation, the annotation and its order are ignored, and the interface
+	 * method is called first. If a subclass annotates a method with the same
+	 * order as an annotated method in its superclass hierarchy, then the
+	 * subclass's method is called first, otherwise the order values among all
+	 * annotated methods in the class and its superclass hierarchy determine
+	 * call order.
+	 */
+	int order() default Integer.MAX_VALUE;
+}