diff --git a/src/keepanno/java/androidx/annotation/keep/AnnotationPattern.java b/src/keepanno/java/androidx/annotation/keep/AnnotationPattern.java
new file mode 100644
index 0000000..aac8b68
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/AnnotationPattern.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A pattern structure for matching annotations.
+ *
+ * <p>If no properties are set, the default pattern matches any annotation with a runtime retention
+ * policy.
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface AnnotationPattern {
+
+  /**
+   * Define the annotation-name pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining annotation-name:
+   *
+   * <ul>
+   *   <li>constant
+   *   <li>namePattern
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any annotation name.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String name() default "";
+
+  /**
+   * Define the annotation-name pattern by reference to a {@code Class} constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining annotation-name:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>namePattern
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any annotation name.
+   *
+   * @return The Class constant that defines the annotation.
+   */
+  Class<?> constant() default Object.class;
+
+  /**
+   * Define the annotation-name pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining annotation-name:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>constant
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any annotation name.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern namePattern() default @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Specify which retention policies must be set for the annotations.
+   *
+   * <p>Matches annotations with matching retention policies
+   *
+   * @return Retention policies. By default {@code RetentionPolicy.RUNTIME}.
+   */
+  RetentionPolicy[] retention() default {RetentionPolicy.RUNTIME};
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/CheckOptimizedOut.java b/src/keepanno/java/androidx/annotation/keep/CheckOptimizedOut.java
new file mode 100644
index 0000000..122ed7e
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/CheckOptimizedOut.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Mark that an item must be optimized out of the residual program.
+ *
+ * <p>An item is optimized out if its declaration is no longer present in the residual program. This
+ * can happen due to many distinct optimizations. For example, it may be dead code and removed by
+ * the usual shrinking. The item's declaration may also be removed if it could be inlined at all
+ * usages, in which case the output may still contain a value if it was a field, or instructions if
+ * it was a method.
+ *
+ * <p>CAUTION: Because of the dependency on shrinker internal optimizations and details such as
+ * inlining vs merging, the use of this annotation is somewhat unreliable and should be used with
+ * caution. In most cases it is more appropriate to use {@link CheckRemoved}.
+ */
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Retention(RetentionPolicy.CLASS)
+public @interface CheckOptimizedOut {
+
+  String description() default "";
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/CheckRemoved.java b/src/keepanno/java/androidx/annotation/keep/CheckRemoved.java
new file mode 100644
index 0000000..20d2d5d
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/CheckRemoved.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Mark that an item must be fully removed from the residual program.
+ *
+ * <p>Being removed from the program means that the item declaration is not present at all in the
+ * residual program. For example, inlined functions are not considered removed. If content of the
+ * item is allowed to be in the residual, use {@link CheckOptimizedOut}.
+ *
+ * <p>A class is removed if all of its members are removed and no references to the class remain.
+ */
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Retention(RetentionPolicy.CLASS)
+public @interface CheckRemoved {
+
+  String description() default "";
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/ClassAccessFlags.java b/src/keepanno/java/androidx/annotation/keep/ClassAccessFlags.java
new file mode 100644
index 0000000..0d4e765
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/ClassAccessFlags.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+/**
+ * Valid matches on class access flags and their negations.
+ *
+ * <p>The negated elements make it easier to express the inverse as we cannot use a "not/negation"
+ * operation syntactically.
+ */
+public enum ClassAccessFlags {
+  PUBLIC,
+  NON_PUBLIC,
+  PACKAGE_PRIVATE,
+  NON_PACKAGE_PRIVATE,
+  FINAL,
+  NON_FINAL,
+  INTERFACE,
+  NON_INTERFACE,
+  ABSTRACT,
+  NON_ABSTRACT,
+  SYNTHETIC,
+  NON_SYNTHETIC,
+  ANNOTATION,
+  NON_ANNOTATION,
+  ENUM,
+  NON_ENUM
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/ClassNamePattern.java b/src/keepanno/java/androidx/annotation/keep/ClassNamePattern.java
new file mode 100644
index 0000000..299bf04
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/ClassNamePattern.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A pattern structure for matching names of classes and interfaces.
+ *
+ * <p>If no properties are set, the default pattern matches any name of a class or interface.
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface ClassNamePattern {
+
+  /**
+   * Define the class-name pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>constant
+   *   <li>unqualifiedName
+   *   <li>unqualifiedNamePattern
+   *   <li>packageName
+   * </ul>
+   *
+   * @return The qualified class name that defines the class.
+   */
+  String name() default "";
+
+  /**
+   * Define the class-name pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>unqualifiedName
+   *   <li>unqualifiedNamePattern
+   *   <li>packageName
+   * </ul>
+   *
+   * @return The class-constant that defines the class.
+   */
+  Class<?> constant() default Object.class;
+
+  /**
+   * Exact and unqualified name of the class or interface.
+   *
+   * <p>For example, the unqualified name of {@code com.example.MyClass} is {@code MyClass}. Note
+   * that for inner classes a `$` will appear in the unqualified name,such as, {@code
+   * MyClass$MyInnerClass}.
+   *
+   * <p>The default matches any unqualified name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-unqualified-name:
+   *
+   * <ul>
+   *   <li>unqualifiedNamePattern
+   *   <li>name
+   *   <li>constant
+   * </ul>
+   */
+  String unqualifiedName() default "";
+
+  /**
+   * Define the unqualified class-name pattern by a string pattern.
+   *
+   * <p>The default matches any unqualified name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-unqualified-name:
+   *
+   * <ul>
+   *   <li>unqualifiedName
+   *   <li>name
+   *   <li>constant
+   * </ul>
+   *
+   * @return The string pattern of the unqualified class name.
+   */
+  StringPattern unqualifiedNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Exact package name of the class or interface.
+   *
+   * <p>For example, the package of {@code com.example.MyClass} is {@code com.example}.
+   *
+   * <p>The default matches any package.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-package-name:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>constant
+   * </ul>
+   */
+  String packageName() default "";
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/FieldAccessFlags.java b/src/keepanno/java/androidx/annotation/keep/FieldAccessFlags.java
new file mode 100644
index 0000000..9b28dec
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/FieldAccessFlags.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+/**
+ * Valid matches on field access flags and their negations.
+ *
+ * <p>The negated elements make it easier to express the inverse as we cannot use a "not/negation"
+ * operation syntactically.
+ */
+public enum FieldAccessFlags {
+  // General member flags.
+  PUBLIC,
+  NON_PUBLIC,
+  PRIVATE,
+  NON_PRIVATE,
+  PROTECTED,
+  NON_PROTECTED,
+  PACKAGE_PRIVATE,
+  NON_PACKAGE_PRIVATE,
+  STATIC,
+  NON_STATIC,
+  FINAL,
+  NON_FINAL,
+  SYNTHETIC,
+  NON_SYNTHETIC,
+  // Field specific flags.
+  VOLATILE,
+  NON_VOLATILE,
+  TRANSIENT,
+  NON_TRANSIENT,
+  // ENUM - No PG parser support.
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/InstanceOfPattern.java b/src/keepanno/java/androidx/annotation/keep/InstanceOfPattern.java
new file mode 100644
index 0000000..9e55d6a
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/InstanceOfPattern.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A pattern structure for matching instances of classes and interfaces.
+ *
+ * <p>If no properties are set, the default pattern matches any instance.
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface InstanceOfPattern {
+
+  /**
+   * True if the pattern should include the directly matched classes.
+   *
+   * <p>If false, the pattern is exclusive and only matches classes that are strict subclasses of
+   * the pattern.
+   */
+  boolean inclusive() default true;
+
+  /** Instances of classes matching the class-name pattern. */
+  ClassNamePattern classNamePattern() default @ClassNamePattern(unqualifiedName = "");
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/KeepBinding.java b/src/keepanno/java/androidx/annotation/keep/KeepBinding.java
new file mode 100644
index 0000000..a15e97e
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/KeepBinding.java
@@ -0,0 +1,722 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A binding of a keep item.
+ *
+ * <p>Bindings allow referencing the exact instance of a match from a condition in other conditions
+ * and/or targets. It can also be used to reduce duplication of targets by sharing patterns.
+ *
+ * <p>An item can be:
+ *
+ * <ul>
+ *   <li>a pattern on classes;
+ *   <li>a pattern on methods; or
+ *   <li>a pattern on fields.
+ * </ul>
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface KeepBinding {
+
+  /**
+   * Name with which other bindings, conditions or targets can reference the bound item pattern.
+   *
+   * @return Name of the binding.
+   */
+  String bindingName();
+
+  /**
+   * Specify the kind of this item pattern.
+   *
+   * <p>Possible values are:
+   *
+   * <ul>
+   *   <li>{@link KeepItemKind#ONLY_CLASS}
+   *   <li>{@link KeepItemKind#ONLY_MEMBERS}
+   *   <li>{@link KeepItemKind#ONLY_METHODS}
+   *   <li>{@link KeepItemKind#ONLY_FIELDS}
+   *   <li>{@link KeepItemKind#CLASS_AND_MEMBERS}
+   *   <li>{@link KeepItemKind#CLASS_AND_METHODS}
+   *   <li>{@link KeepItemKind#CLASS_AND_FIELDS}
+   * </ul>
+   *
+   * <p>If unspecified the default kind for an item depends on its member patterns:
+   *
+   * <ul>
+   *   <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined
+   *   <li>{@link KeepItemKind#ONLY_METHODS} if method patterns are defined
+   *   <li>{@link KeepItemKind#ONLY_FIELDS} if field patterns are defined
+   *   <li>{@link KeepItemKind#ONLY_MEMBERS} otherwise.
+   * </ul>
+   *
+   * @return The kind for this pattern.
+   */
+  KeepItemKind kind() default KeepItemKind.DEFAULT;
+
+  /**
+   * Define the class pattern by reference to a binding.
+   *
+   * <p>Mutually exclusive with the following other properties defining class:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classConstant
+   *   <li>classNamePattern
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class.
+   *
+   * @return The name of the binding that defines the class.
+   */
+  String classFromBinding() default "";
+
+  /**
+   * Define the class-name pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>classConstant
+   *   <li>classNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The qualified class name that defines the class.
+   */
+  String className() default "";
+
+  /**
+   * Define the class-name pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The class-constant that defines the class.
+   */
+  Class<?> classConstant() default Object.class;
+
+  /**
+   * Define the class-name pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classConstant
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The class-name pattern that defines the class.
+   */
+  ClassNamePattern classNamePattern() default @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The qualified class name that defines what instance-of the class must be.
+   */
+  String instanceOfClassName() default "";
+
+  /**
+   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
+   *
+   * <p>The pattern is exclusive in that it does not match classes that are instances of the
+   * pattern, but only those that are instances of classes that are subclasses of the pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The qualified class name that defines what instance-of the class must be.
+   */
+  String instanceOfClassNameExclusive() default "";
+
+  /**
+   * Define the instance-of pattern as classes that are instances the referenced Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The class constant that defines what instance-of the class must be.
+   */
+  Class<?> instanceOfClassConstant() default Object.class;
+
+  /**
+   * Define the instance-of pattern as classes that are instances the referenced Class constant.
+   *
+   * <p>The pattern is exclusive in that it does not match classes that are instances of the
+   * pattern, but only those that are instances of classes that are subclasses of the pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The class constant that defines what instance-of the class must be.
+   */
+  Class<?> instanceOfClassConstantExclusive() default Object.class;
+
+  /**
+   * Define the instance-of with a pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The pattern that defines what instance-of the class must be.
+   */
+  InstanceOfPattern instanceOfPattern() default @InstanceOfPattern();
+
+  /**
+   * Define the class-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classAnnotatedByClassNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String classAnnotatedByClassName() default "";
+
+  /**
+   * Define the class-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> classAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the class-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern classAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassConstant
+   *   <li>memberAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String memberAnnotatedByClassName() default "";
+
+  /**
+   * Define the member-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> memberAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the member-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern memberAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * @return The member access-flag constraints that must be met.
+   */
+  MemberAccessFlags[] memberAccess() default {};
+
+  /**
+   * Define the method-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassConstant
+   *   <li>methodAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String methodAnnotatedByClassName() default "";
+
+  /**
+   * Define the method-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> methodAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the method-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern methodAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the method-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * method-access flags.
+   *
+   * @return The method access-flag constraints that must be met.
+   */
+  MethodAccessFlags[] methodAccess() default {};
+
+  /**
+   * Define the method-name pattern by an exact method name.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the property `methodNamePattern` also defining method-name.
+   *
+   * @return The exact method name of the method.
+   */
+  String methodName() default "";
+
+  /**
+   * Define the method-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the property `methodName` also defining method-name.
+   *
+   * @return The string pattern of the method name.
+   */
+  StringPattern methodNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the method return-type pattern by a fully qualified type or 'void'.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnTypeConstant
+   *   <li>methodReturnTypePattern
+   * </ul>
+   *
+   * @return The qualified type name of the method return type.
+   */
+  String methodReturnType() default "";
+
+  /**
+   * Define the method return-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypePattern
+   * </ul>
+   *
+   * @return A class constant denoting the type of the method return type.
+   */
+  Class<?> methodReturnTypeConstant() default Object.class;
+
+  /**
+   * Define the method return-type pattern by a type pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypeConstant
+   * </ul>
+   *
+   * @return The pattern of the method return type.
+   */
+  TypePattern methodReturnTypePattern() default @TypePattern(name = "");
+
+  /**
+   * Define the method parameters pattern by a list of fully qualified types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
+   *
+   * @return The list of qualified type names of the method parameters.
+   */
+  String[] methodParameters() default {""};
+
+  /**
+   * Define the method parameters pattern by a list of patterns on types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the property `methodParameters` also defining parameters.
+   *
+   * @return The list of type patterns for the method parameters.
+   */
+  TypePattern[] methodParameterTypePatterns() default {@TypePattern(name = "")};
+
+  /**
+   * Define the field-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassConstant
+   *   <li>fieldAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String fieldAnnotatedByClassName() default "";
+
+  /**
+   * Define the field-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> fieldAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the field-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern fieldAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the field-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any
+   * field-access flags.
+   *
+   * @return The field access-flag constraints that must be met.
+   */
+  FieldAccessFlags[] fieldAccess() default {};
+
+  /**
+   * Define the field-name pattern by an exact field name.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+   *
+   * @return The exact field name of the field.
+   */
+  String fieldName() default "";
+
+  /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldName` also defining field-name.
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the field-type pattern by a fully qualified type.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldTypeConstant
+   *   <li>fieldTypePattern
+   * </ul>
+   *
+   * @return The qualified type name for the field type.
+   */
+  String fieldType() default "";
+
+  /**
+   * Define the field-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypePattern
+   * </ul>
+   *
+   * @return The class constant for the field type.
+   */
+  Class<?> fieldTypeConstant() default Object.class;
+
+  /**
+   * Define the field-type pattern by a pattern on types.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypeConstant
+   * </ul>
+   *
+   * @return The type pattern for the field type.
+   */
+  TypePattern fieldTypePattern() default @TypePattern(name = "");
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/KeepCondition.java b/src/keepanno/java/androidx/annotation/keep/KeepCondition.java
new file mode 100644
index 0000000..1a0cd79
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/KeepCondition.java
@@ -0,0 +1,745 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A condition for a keep edge.
+ *
+ * <p>The condition denotes an item used as a precondition of a rule. An item can be:
+ *
+ * <ul>
+ *   <li>a pattern on classes;
+ *   <li>a pattern on methods; or
+ *   <li>a pattern on fields.
+ * </ul>
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface KeepCondition {
+
+  /**
+   * Define the class pattern by reference to a binding.
+   *
+   * <p>Mutually exclusive with the following other properties defining class:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classConstant
+   *   <li>classNamePattern
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class.
+   *
+   * @return The name of the binding that defines the class.
+   */
+  String classFromBinding() default "";
+
+  /**
+   * Define the class-name pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>classConstant
+   *   <li>classNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The qualified class name that defines the class.
+   */
+  String className() default "";
+
+  /**
+   * Define the class-name pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The class-constant that defines the class.
+   */
+  Class<?> classConstant() default Object.class;
+
+  /**
+   * Define the class-name pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classConstant
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The class-name pattern that defines the class.
+   */
+  ClassNamePattern classNamePattern() default @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The qualified class name that defines what instance-of the class must be.
+   */
+  String instanceOfClassName() default "";
+
+  /**
+   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
+   *
+   * <p>The pattern is exclusive in that it does not match classes that are instances of the
+   * pattern, but only those that are instances of classes that are subclasses of the pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The qualified class name that defines what instance-of the class must be.
+   */
+  String instanceOfClassNameExclusive() default "";
+
+  /**
+   * Define the instance-of pattern as classes that are instances the referenced Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The class constant that defines what instance-of the class must be.
+   */
+  Class<?> instanceOfClassConstant() default Object.class;
+
+  /**
+   * Define the instance-of pattern as classes that are instances the referenced Class constant.
+   *
+   * <p>The pattern is exclusive in that it does not match classes that are instances of the
+   * pattern, but only those that are instances of classes that are subclasses of the pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The class constant that defines what instance-of the class must be.
+   */
+  Class<?> instanceOfClassConstantExclusive() default Object.class;
+
+  /**
+   * Define the instance-of with a pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The pattern that defines what instance-of the class must be.
+   */
+  InstanceOfPattern instanceOfPattern() default @InstanceOfPattern();
+
+  /**
+   * Define the class-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classAnnotatedByClassNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String classAnnotatedByClassName() default "";
+
+  /**
+   * Define the class-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> classAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the class-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern classAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member pattern in full by a reference to a binding.
+   *
+   * <p>Mutually exclusive with all other class and member pattern properties. When a member binding
+   * is referenced this item is defined to be that item, including its class and member patterns.
+   *
+   * @return The binding name that defines the member.
+   */
+  String memberFromBinding() default "";
+
+  /**
+   * Define the member-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassConstant
+   *   <li>memberAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String memberAnnotatedByClassName() default "";
+
+  /**
+   * Define the member-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> memberAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the member-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern memberAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>Mutually exclusive with the property `memberFromBinding` also defining member-access.
+   *
+   * @return The member access-flag constraints that must be met.
+   */
+  MemberAccessFlags[] memberAccess() default {};
+
+  /**
+   * Define the method-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassConstant
+   *   <li>methodAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String methodAnnotatedByClassName() default "";
+
+  /**
+   * Define the method-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> methodAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the method-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern methodAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the method-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * method-access flags.
+   *
+   * <p>Mutually exclusive with the property `memberFromBinding` also defining method-access.
+   *
+   * @return The method access-flag constraints that must be met.
+   */
+  MethodAccessFlags[] methodAccess() default {};
+
+  /**
+   * Define the method-name pattern by an exact method name.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-name:
+   *
+   * <ul>
+   *   <li>methodNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The exact method name of the method.
+   */
+  String methodName() default "";
+
+  /**
+   * Define the method-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-name:
+   *
+   * <ul>
+   *   <li>methodName
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The string pattern of the method name.
+   */
+  StringPattern methodNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the method return-type pattern by a fully qualified type or 'void'.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnTypeConstant
+   *   <li>methodReturnTypePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The qualified type name of the method return type.
+   */
+  String methodReturnType() default "";
+
+  /**
+   * Define the method return-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return A class constant denoting the type of the method return type.
+   */
+  Class<?> methodReturnTypeConstant() default Object.class;
+
+  /**
+   * Define the method return-type pattern by a type pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypeConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The pattern of the method return type.
+   */
+  TypePattern methodReturnTypePattern() default @TypePattern(name = "");
+
+  /**
+   * Define the method parameters pattern by a list of fully qualified types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the following other properties defining parameters:
+   *
+   * <ul>
+   *   <li>methodParameterTypePatterns
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The list of qualified type names of the method parameters.
+   */
+  String[] methodParameters() default {""};
+
+  /**
+   * Define the method parameters pattern by a list of patterns on types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the following other properties defining parameters:
+   *
+   * <ul>
+   *   <li>methodParameters
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The list of type patterns for the method parameters.
+   */
+  TypePattern[] methodParameterTypePatterns() default {@TypePattern(name = "")};
+
+  /**
+   * Define the field-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassConstant
+   *   <li>fieldAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String fieldAnnotatedByClassName() default "";
+
+  /**
+   * Define the field-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> fieldAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the field-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern fieldAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the field-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any
+   * field-access flags.
+   *
+   * <p>Mutually exclusive with the property `memberFromBinding` also defining field-access.
+   *
+   * @return The field access-flag constraints that must be met.
+   */
+  FieldAccessFlags[] fieldAccess() default {};
+
+  /**
+   * Define the field-name pattern by an exact field name.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-name:
+   *
+   * <ul>
+   *   <li>fieldNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The exact field name of the field.
+   */
+  String fieldName() default "";
+
+  /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-name:
+   *
+   * <ul>
+   *   <li>fieldName
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the field-type pattern by a fully qualified type.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldTypeConstant
+   *   <li>fieldTypePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The qualified type name for the field type.
+   */
+  String fieldType() default "";
+
+  /**
+   * Define the field-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The class constant for the field type.
+   */
+  Class<?> fieldTypeConstant() default Object.class;
+
+  /**
+   * Define the field-type pattern by a pattern on types.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypeConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The type pattern for the field type.
+   */
+  TypePattern fieldTypePattern() default @TypePattern(name = "");
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/KeepConstraint.java b/src/keepanno/java/androidx/annotation/keep/KeepConstraint.java
new file mode 100644
index 0000000..19f48dc
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/KeepConstraint.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+
+package androidx.annotation.keep;
+
+/**
+ * Usage constraints for how a target is used and what must be kept.
+ *
+ * <p>Providing the constraints on how an item is being used allows shrinkers to optimize or remove
+ * aspects of the item that do not change that usage constraint.
+ *
+ * <p>For example, invoking a method reflectively does not use any annotations on that method, and
+ * it is safe to remove the annotations. However, it would not be safe to remove parameters from the
+ * method.
+ */
+public enum KeepConstraint {
+  /**
+   * Indicates that the target item is being looked up reflectively.
+   *
+   * <p>Looking up an item reflectively requires that it remains on its expected context, which for
+   * a method or field means it must remain on its defining class. In other words, the item cannot
+   * be removed or moved.
+   *
+   * <p>Note that looking up a member does not imply that the holder class of the member can be
+   * looked up. If both the class and the member need to be looked, make sure to have a target for
+   * both.
+   *
+   * <p>Note also that the item can be looked up within its context but no constraint is placed on
+   * its name, accessibility or any other properties of the item.
+   *
+   * <p>If assumptions are being made about other aspects, additional constraints and targets should
+   * be added to the keep annotation.
+   */
+  LOOKUP,
+
+  /**
+   * Indicates that the name of the target item is being used.
+   *
+   * <p>This usage constraint is needed if the target is being looked up reflectively by using its
+   * name. Setting it will prohibit renaming of the target item.
+   *
+   * <p>Note that preserving the name of a member does not imply that the holder class of the member
+   * will preserve its qualified or simple name. If both the class and the member need to preserve
+   * their names, make sure to have a target for both.
+   *
+   * <p>Note that preserving the name of a member does not preserve the types of its parameters or
+   * its return type for methods or the type for fields.
+   */
+  NAME,
+
+  /**
+   * Indicates that the visibility of the target must be at least as visible as declared.
+   *
+   * <p>Setting this constraint ensures that any (reflective) access to the target that is allowed
+   * remains valid. In other words, a public class, field or method must remain public. For a
+   * non-public target its visibility may be relaxed in the direction: {@code private ->
+   * package-private -> protected -> public}.
+   *
+   * <p>Note that this constraint does not place any restrictions on any other accesses flags than
+   * visibility. In particular, flags such a static, final and abstract may change.
+   *
+   * <p>Used together with {@link #VISIBILITY_RESTRICT} the visibility will remain invariant.
+   */
+  VISIBILITY_RELAX,
+
+  /**
+   * Indicates that the visibility of the target must be at most as visible as declared.
+   *
+   * <p>Setting this constraint ensures that any (reflective) access to the target that would fail
+   * will continue to fail. In other words, a private class, field or method must remain private.
+   * Concretely the visibility of the target item may be restricted in the direction: {@code public
+   * -> protected -> package-private -> private}.
+   *
+   * <p>Note that this constraint does not place any restrictions on any other accesses flags than
+   * visibility. In particular, flags such a static, final and abstract may change.
+   *
+   * <p>Used together with {@link #VISIBILITY_RELAX} the visibility will remain invariant.
+   */
+  VISIBILITY_RESTRICT,
+
+  /**
+   * Indicates that the visibility of the target must remain as declared.
+   *
+   * <p>Note that this constraint does not place any restrictions on any other accesses flags than
+   * visibility. In particular, flags such a static, final and abstract may change.
+   *
+   * <p>This is equivalent to using both {@link #VISIBILITY_RELAX} and {@link #VISIBILITY_RESTRICT}.
+   */
+  VISIBILITY_INVARIANT,
+
+  /**
+   * Indicates that the class target is being instantiated reflectively.
+   *
+   * <p>This usage constraint is only valid on class targets.
+   *
+   * <p>Being instantiated prohibits reasoning about the class instances at compile time. In other
+   * words, the compiler must assume the class to be possibly instantiated at all times.
+   *
+   * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain a
+   * class. This constraint only implies that if the class is referenced in the program it may be
+   * instantiated.
+   */
+  CLASS_INSTANTIATE,
+
+  /**
+   * Indicates that the method target is being invoked reflectively.
+   *
+   * <p>This usage constraint is only valid on method targets.
+   *
+   * <p>To be invoked reflectively the method must retain the structure of the method. Thus, unused
+   * arguments cannot be removed. However, it does not imply preserving the types of its parameters
+   * or its return type. If the parameter types are being obtained reflectively then those need a
+   * keep target independent of the method.
+   *
+   * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain a
+   * method reference. This constraint only implies that if the method is referenced in the program
+   * it may be reflectively invoked.
+   */
+  METHOD_INVOKE,
+
+  /**
+   * Indicates that the field target is reflectively read from.
+   *
+   * <p>This usage constraint is only valid on field targets.
+   *
+   * <p>A field that has its value read from, requires that the field value must remain. Thus, if
+   * field remains, its value cannot be replaced. It can still be removed in full, be inlined and
+   * its value reasoned about at compile time.
+   *
+   * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain
+   * access to the field. This constraint only implies that if a field is referenced then it may be
+   * reflectively read.
+   */
+  FIELD_GET,
+
+  /**
+   * Indicates that the field target is reflectively written to.
+   *
+   * <p>This usage constraint is only valid on field targets.
+   *
+   * <p>A field that has its value written to, requires that the field value must be treated as
+   * unknown.
+   *
+   * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain
+   * access to the field. This constraint only implies that if a field is referenced then it may be
+   * reflectively written.
+   */
+  FIELD_SET,
+
+  /**
+   * Indicates that the target method can be replaced by an alternative definition at runtime.
+   *
+   * <p>This usage constraint is only valid on method targets.
+   *
+   * <p>Replacing a method implies that the concrete implementation of the target cannot be known at
+   * compile time. Thus, it cannot be moved or otherwise assumed to have particular properties.
+   * Being able to replace the method still allows the compiler to fully remove it if it is
+   * statically found to be unused.
+   *
+   * <p>Note also that no restriction is placed on the method name. To ensure the same name add
+   * {@link #NAME} to the constraint set.
+   */
+  METHOD_REPLACE,
+
+  /**
+   * Indicates that the target field can be replaced by an alternative definition at runtime.
+   *
+   * <p>This usage constraint is only valid on field targets.
+   *
+   * <p>Replacing a field implies that the concrete implementation of the target cannot be known at
+   * compile time. Thus, it cannot be moved or otherwise assumed to have particular properties.
+   * Being able to replace the method still allows the compiler to fully remove it if it is
+   * statically found to be unused.
+   *
+   * <p>Note also that no restriction is placed on the field name. To ensure the same name add
+   * {@link #NAME} to the constraint set.
+   */
+  FIELD_REPLACE,
+
+  /**
+   * Indicates that the target item must never be inlined or merged.
+   *
+   * <p>This ensures that if the item is actually used in the program it will remain in some form.
+   * For example, a method may still be renamed, but it will be present as a frame in stack traces
+   * produced by the runtime (before potentially being retraced). For classes, they too may be
+   * renamed, but will not have been merged with other classes or have their allocations fully
+   * eliminated (aka class inlining).
+   *
+   * <p>For members this also ensures that the field value or method body cannot be reasoned about
+   * outside the item itself. For example, a field value cannot be assumed to be a particular value,
+   * and a method cannot be assumed to have particular properties for callers, such as always
+   * throwing or a constant return value.
+   */
+  NEVER_INLINE,
+
+  /**
+   * Indicates that the class hierarchy below the target class may be extended at runtime.
+   *
+   * <p>This ensures that new subtypes of the target class can later be linked and/or class loaded
+   * at runtime.
+   *
+   * <p>This does not ensure that the class remains if it is otherwise dead code and can be fully
+   * removed.
+   *
+   * <p>Note that this constraint does not ensure that particular methods remain on the target
+   * class. If methods or fields of the target class are being targeted by a subclass that was
+   * classloaded or linked later, then keep annotations are needed for those targets too. Such
+   * non-visible uses requires the same annotations to preserve as for reflective uses.
+   */
+  CLASS_OPEN_HIERARCHY,
+
+  /**
+   * Indicates that the target item must retain its generic signature if present.
+   *
+   * <p>This ensures that the generic signature remains, but does not prohibit rewriting of the
+   * generic signature. For example, if a type present in the generic signature is renamed, the
+   * generic signature will also be updated to now refer to the type by its renamed name.
+   *
+   * <p>Note that this constraint does not otherwise restrict what can be done to the target, such
+   * as removing the target completely, inlining it, etc.
+   */
+  GENERIC_SIGNATURE,
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/KeepEdge.java b/src/keepanno/java/androidx/annotation/keep/KeepEdge.java
new file mode 100644
index 0000000..b4e3830
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/KeepEdge.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Retention(RetentionPolicy.CLASS)
+public @interface KeepEdge {
+  String description() default "";
+
+  KeepBinding[] bindings() default {};
+
+  KeepCondition[] preconditions() default {};
+
+  KeepTarget[] consequences();
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/KeepForApi.java b/src/keepanno/java/androidx/annotation/keep/KeepForApi.java
new file mode 100644
index 0000000..7ad9e61
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/KeepForApi.java
@@ -0,0 +1,481 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation to mark a class, field or method as part of a library API surface.
+ *
+ * <p>When a class is annotated, member patterns can be used to define which members are to be kept.
+ * When no member patterns are specified the default pattern matches all public and protected
+ * members.
+ *
+ * <p>When a member is annotated, the member patterns cannot be used as the annotated member itself
+ * fully defines the item to be kept (i.e., itself).
+ */
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Retention(RetentionPolicy.CLASS)
+public @interface KeepForApi {
+
+  /**
+   * Optional description to document the reason for this annotation.
+   *
+   * @return The descriptive message. Defaults to no description.
+   */
+  String description() default "";
+
+  /**
+   * Additional targets to be kept as part of the API surface.
+   *
+   * @return List of additional target consequences. Defaults to no additional target consequences.
+   */
+  KeepTarget[] additionalTargets() default {};
+
+  /**
+   * Specify the kind of this item pattern.
+   *
+   * <p>Default kind is {@link KeepItemKind#CLASS_AND_MEMBERS}, meaning the annotated class and/or
+   * member is to be kept. When annotating a class this can be set to {@link
+   * KeepItemKind#ONLY_CLASS} to avoid patterns on any members. That can be useful when the API
+   * members are themselves explicitly annotated.
+   *
+   * <p>It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member. Also, it
+   * is never valid to use kind {@link KeepItemKind#ONLY_MEMBERS} as the API surface must keep the
+   * class if any member is to be accessible.
+   *
+   * @return The kind for this pattern.
+   */
+  KeepItemKind kind() default KeepItemKind.DEFAULT;
+
+  /**
+   * Define the member-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassConstant
+   *   <li>memberAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String memberAnnotatedByClassName() default "";
+
+  /**
+   * Define the member-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> memberAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the member-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern memberAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * @return The member access-flag constraints that must be met.
+   */
+  MemberAccessFlags[] memberAccess() default {};
+
+  /**
+   * Define the method-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassConstant
+   *   <li>methodAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String methodAnnotatedByClassName() default "";
+
+  /**
+   * Define the method-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> methodAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the method-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern methodAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the method-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * method-access flags.
+   *
+   * @return The method access-flag constraints that must be met.
+   */
+  MethodAccessFlags[] methodAccess() default {};
+
+  /**
+   * Define the method-name pattern by an exact method name.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the property `methodNamePattern` also defining method-name.
+   *
+   * @return The exact method name of the method.
+   */
+  String methodName() default "";
+
+  /**
+   * Define the method-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the property `methodName` also defining method-name.
+   *
+   * @return The string pattern of the method name.
+   */
+  StringPattern methodNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the method return-type pattern by a fully qualified type or 'void'.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnTypeConstant
+   *   <li>methodReturnTypePattern
+   * </ul>
+   *
+   * @return The qualified type name of the method return type.
+   */
+  String methodReturnType() default "";
+
+  /**
+   * Define the method return-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypePattern
+   * </ul>
+   *
+   * @return A class constant denoting the type of the method return type.
+   */
+  Class<?> methodReturnTypeConstant() default Object.class;
+
+  /**
+   * Define the method return-type pattern by a type pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypeConstant
+   * </ul>
+   *
+   * @return The pattern of the method return type.
+   */
+  TypePattern methodReturnTypePattern() default @TypePattern(name = "");
+
+  /**
+   * Define the method parameters pattern by a list of fully qualified types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
+   *
+   * @return The list of qualified type names of the method parameters.
+   */
+  String[] methodParameters() default {""};
+
+  /**
+   * Define the method parameters pattern by a list of patterns on types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the property `methodParameters` also defining parameters.
+   *
+   * @return The list of type patterns for the method parameters.
+   */
+  TypePattern[] methodParameterTypePatterns() default {@TypePattern(name = "")};
+
+  /**
+   * Define the field-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassConstant
+   *   <li>fieldAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String fieldAnnotatedByClassName() default "";
+
+  /**
+   * Define the field-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> fieldAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the field-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern fieldAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the field-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any
+   * field-access flags.
+   *
+   * @return The field access-flag constraints that must be met.
+   */
+  FieldAccessFlags[] fieldAccess() default {};
+
+  /**
+   * Define the field-name pattern by an exact field name.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+   *
+   * @return The exact field name of the field.
+   */
+  String fieldName() default "";
+
+  /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldName` also defining field-name.
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the field-type pattern by a fully qualified type.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldTypeConstant
+   *   <li>fieldTypePattern
+   * </ul>
+   *
+   * @return The qualified type name for the field type.
+   */
+  String fieldType() default "";
+
+  /**
+   * Define the field-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypePattern
+   * </ul>
+   *
+   * @return The class constant for the field type.
+   */
+  Class<?> fieldTypeConstant() default Object.class;
+
+  /**
+   * Define the field-type pattern by a pattern on types.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypeConstant
+   * </ul>
+   *
+   * @return The type pattern for the field type.
+   */
+  TypePattern fieldTypePattern() default @TypePattern(name = "");
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/KeepItemKind.java b/src/keepanno/java/androidx/annotation/keep/KeepItemKind.java
new file mode 100644
index 0000000..5ffc9d7
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/KeepItemKind.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+public enum KeepItemKind {
+  ONLY_CLASS,
+  ONLY_MEMBERS,
+  ONLY_METHODS,
+  ONLY_FIELDS,
+  CLASS_AND_MEMBERS,
+  CLASS_AND_METHODS,
+  CLASS_AND_FIELDS,
+  DEFAULT
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/KeepOption.java b/src/keepanno/java/androidx/annotation/keep/KeepOption.java
new file mode 100644
index 0000000..b635d1c
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/KeepOption.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+public enum KeepOption {
+  SHRINKING,
+  OPTIMIZATION,
+  OBFUSCATION,
+  ACCESS_MODIFICATION,
+  ANNOTATION_REMOVAL,
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/KeepTarget.java b/src/keepanno/java/androidx/annotation/keep/KeepTarget.java
new file mode 100644
index 0000000..96196a9
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/KeepTarget.java
@@ -0,0 +1,842 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A target for a keep edge.
+ *
+ * <p>The target denotes an item along with options for what to keep. An item can be:
+ *
+ * <ul>
+ *   <li>a pattern on classes;
+ *   <li>a pattern on methods; or
+ *   <li>a pattern on fields.
+ * </ul>
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface KeepTarget {
+
+  /**
+   * Specify the kind of this item pattern.
+   *
+   * <p>Possible values are:
+   *
+   * <ul>
+   *   <li>{@link KeepItemKind#ONLY_CLASS}
+   *   <li>{@link KeepItemKind#ONLY_MEMBERS}
+   *   <li>{@link KeepItemKind#ONLY_METHODS}
+   *   <li>{@link KeepItemKind#ONLY_FIELDS}
+   *   <li>{@link KeepItemKind#CLASS_AND_MEMBERS}
+   *   <li>{@link KeepItemKind#CLASS_AND_METHODS}
+   *   <li>{@link KeepItemKind#CLASS_AND_FIELDS}
+   * </ul>
+   *
+   * <p>If unspecified the default kind for an item depends on its member patterns:
+   *
+   * <ul>
+   *   <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined
+   *   <li>{@link KeepItemKind#ONLY_METHODS} if method patterns are defined
+   *   <li>{@link KeepItemKind#ONLY_FIELDS} if field patterns are defined
+   *   <li>{@link KeepItemKind#ONLY_MEMBERS} otherwise.
+   * </ul>
+   *
+   * @return The kind for this pattern.
+   */
+  KeepItemKind kind() default KeepItemKind.DEFAULT;
+
+  /**
+   * Define the usage constraints of the target.
+   *
+   * <p>The specified constraints must remain valid for the target.
+   *
+   * <p>The default constraints depend on the kind of the target. For all targets the default
+   * constraints include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#LOOKUP}
+   *   <li>{@link KeepConstraint#NAME}
+   *   <li>{@link KeepConstraint#VISIBILITY_RELAX}
+   * </ul>
+   *
+   * <p>For classes the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#CLASS_INSTANTIATE}
+   * </ul>
+   *
+   * <p>For methods the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#METHOD_INVOKE}
+   * </ul>
+   *
+   * <p>For fields the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#FIELD_GET}
+   *   <li>{@link KeepConstraint#FIELD_SET}
+   * </ul>
+   *
+   * <p>Mutually exclusive with the property `constraintAdditions` also defining constraints.
+   *
+   * @return Usage constraints for the target.
+   */
+  KeepConstraint[] constraints() default {};
+
+  /**
+   * Add additional usage constraints of the target.
+   *
+   * <p>The specified constraints must remain valid for the target in addition to the default
+   * constraints.
+   *
+   * <p>The default constraints are documented in {@link #constraints}
+   *
+   * <p>Mutually exclusive with the property `constraints` also defining constraints.
+   *
+   * @return Additional usage constraints for the target.
+   */
+  KeepConstraint[] constraintAdditions() default {};
+
+  /**
+   * Patterns for annotations that must remain on the item.
+   *
+   * <p>The annotations matching any of the patterns must remain on the item if the annotation types
+   * remain in the program.
+   *
+   * <p>Note that if the annotation types themselves are unused/removed, then their references on
+   * the item will be removed too. If the annotation types themselves are used reflectively then
+   * they too need a keep annotation or rule to ensure they remain in the program.
+   *
+   * <p>By default no annotation patterns are defined and no annotations are required to remain.
+   *
+   * @return Annotation patterns
+   */
+  AnnotationPattern[] constrainAnnotations() default {};
+
+  /**
+   * Define the class pattern by reference to a binding.
+   *
+   * <p>Mutually exclusive with the following other properties defining class:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classConstant
+   *   <li>classNamePattern
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class.
+   *
+   * @return The name of the binding that defines the class.
+   */
+  String classFromBinding() default "";
+
+  /**
+   * Define the class-name pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>classConstant
+   *   <li>classNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The qualified class name that defines the class.
+   */
+  String className() default "";
+
+  /**
+   * Define the class-name pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The class-constant that defines the class.
+   */
+  Class<?> classConstant() default Object.class;
+
+  /**
+   * Define the class-name pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-name:
+   *
+   * <ul>
+   *   <li>className
+   *   <li>classConstant
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class name.
+   *
+   * @return The class-name pattern that defines the class.
+   */
+  ClassNamePattern classNamePattern() default @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The qualified class name that defines what instance-of the class must be.
+   */
+  String instanceOfClassName() default "";
+
+  /**
+   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
+   *
+   * <p>The pattern is exclusive in that it does not match classes that are instances of the
+   * pattern, but only those that are instances of classes that are subclasses of the pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The qualified class name that defines what instance-of the class must be.
+   */
+  String instanceOfClassNameExclusive() default "";
+
+  /**
+   * Define the instance-of pattern as classes that are instances the referenced Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The class constant that defines what instance-of the class must be.
+   */
+  Class<?> instanceOfClassConstant() default Object.class;
+
+  /**
+   * Define the instance-of pattern as classes that are instances the referenced Class constant.
+   *
+   * <p>The pattern is exclusive in that it does not match classes that are instances of the
+   * pattern, but only those that are instances of classes that are subclasses of the pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfPattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The class constant that defines what instance-of the class must be.
+   */
+  Class<?> instanceOfClassConstantExclusive() default Object.class;
+
+  /**
+   * Define the instance-of with a pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining instance-of:
+   *
+   * <ul>
+   *   <li>instanceOfClassName
+   *   <li>instanceOfClassNameExclusive
+   *   <li>instanceOfClassConstant
+   *   <li>instanceOfClassConstantExclusive
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class instance.
+   *
+   * @return The pattern that defines what instance-of the class must be.
+   */
+  InstanceOfPattern instanceOfPattern() default @InstanceOfPattern();
+
+  /**
+   * Define the class-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classAnnotatedByClassNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String classAnnotatedByClassName() default "";
+
+  /**
+   * Define the class-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassNamePattern
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> classAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the class-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining class-annotated-by:
+   *
+   * <ul>
+   *   <li>classAnnotatedByClassName
+   *   <li>classAnnotatedByClassConstant
+   *   <li>classFromBinding
+   * </ul>
+   *
+   * <p>If none are specified the default is to match any class regardless of what the class is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern classAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member pattern in full by a reference to a binding.
+   *
+   * <p>Mutually exclusive with all other class and member pattern properties. When a member binding
+   * is referenced this item is defined to be that item, including its class and member patterns.
+   *
+   * @return The binding name that defines the member.
+   */
+  String memberFromBinding() default "";
+
+  /**
+   * Define the member-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassConstant
+   *   <li>memberAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String memberAnnotatedByClassName() default "";
+
+  /**
+   * Define the member-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> memberAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the member-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern memberAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>Mutually exclusive with the property `memberFromBinding` also defining member-access.
+   *
+   * @return The member access-flag constraints that must be met.
+   */
+  MemberAccessFlags[] memberAccess() default {};
+
+  /**
+   * Define the method-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassConstant
+   *   <li>methodAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String methodAnnotatedByClassName() default "";
+
+  /**
+   * Define the method-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> methodAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the method-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern methodAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the method-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * method-access flags.
+   *
+   * <p>Mutually exclusive with the property `memberFromBinding` also defining method-access.
+   *
+   * @return The method access-flag constraints that must be met.
+   */
+  MethodAccessFlags[] methodAccess() default {};
+
+  /**
+   * Define the method-name pattern by an exact method name.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-name:
+   *
+   * <ul>
+   *   <li>methodNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The exact method name of the method.
+   */
+  String methodName() default "";
+
+  /**
+   * Define the method-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-name:
+   *
+   * <ul>
+   *   <li>methodName
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The string pattern of the method name.
+   */
+  StringPattern methodNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the method return-type pattern by a fully qualified type or 'void'.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnTypeConstant
+   *   <li>methodReturnTypePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The qualified type name of the method return type.
+   */
+  String methodReturnType() default "";
+
+  /**
+   * Define the method return-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return A class constant denoting the type of the method return type.
+   */
+  Class<?> methodReturnTypeConstant() default Object.class;
+
+  /**
+   * Define the method return-type pattern by a type pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypeConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The pattern of the method return type.
+   */
+  TypePattern methodReturnTypePattern() default @TypePattern(name = "");
+
+  /**
+   * Define the method parameters pattern by a list of fully qualified types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the following other properties defining parameters:
+   *
+   * <ul>
+   *   <li>methodParameterTypePatterns
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The list of qualified type names of the method parameters.
+   */
+  String[] methodParameters() default {""};
+
+  /**
+   * Define the method parameters pattern by a list of patterns on types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the following other properties defining parameters:
+   *
+   * <ul>
+   *   <li>methodParameters
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The list of type patterns for the method parameters.
+   */
+  TypePattern[] methodParameterTypePatterns() default {@TypePattern(name = "")};
+
+  /**
+   * Define the field-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassConstant
+   *   <li>fieldAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String fieldAnnotatedByClassName() default "";
+
+  /**
+   * Define the field-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> fieldAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the field-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern fieldAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the field-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any
+   * field-access flags.
+   *
+   * <p>Mutually exclusive with the property `memberFromBinding` also defining field-access.
+   *
+   * @return The field access-flag constraints that must be met.
+   */
+  FieldAccessFlags[] fieldAccess() default {};
+
+  /**
+   * Define the field-name pattern by an exact field name.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-name:
+   *
+   * <ul>
+   *   <li>fieldNamePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The exact field name of the field.
+   */
+  String fieldName() default "";
+
+  /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-name:
+   *
+   * <ul>
+   *   <li>fieldName
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the field-type pattern by a fully qualified type.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldTypeConstant
+   *   <li>fieldTypePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The qualified type name for the field type.
+   */
+  String fieldType() default "";
+
+  /**
+   * Define the field-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypePattern
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The class constant for the field type.
+   */
+  Class<?> fieldTypeConstant() default Object.class;
+
+  /**
+   * Define the field-type pattern by a pattern on types.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypeConstant
+   *   <li>memberFromBinding
+   * </ul>
+   *
+   * @return The type pattern for the field type.
+   */
+  TypePattern fieldTypePattern() default @TypePattern(name = "");
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/MemberAccessFlags.java b/src/keepanno/java/androidx/annotation/keep/MemberAccessFlags.java
new file mode 100644
index 0000000..dd6c1d6
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/MemberAccessFlags.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+/**
+ * Valid matches on member access flags and their negations.
+ *
+ * <p>The negated elements make it easier to express the inverse as we cannot use a "not/negation"
+ * operation syntactically.
+ */
+public enum MemberAccessFlags {
+  PUBLIC,
+  NON_PUBLIC,
+  PROTECTED,
+  NON_PROTECTED,
+  PACKAGE_PRIVATE,
+  NON_PACKAGE_PRIVATE,
+  PRIVATE,
+  NON_PRIVATE,
+  STATIC,
+  NON_STATIC,
+  FINAL,
+  NON_FINAL,
+  SYNTHETIC,
+  NON_SYNTHETIC
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/MethodAccessFlags.java b/src/keepanno/java/androidx/annotation/keep/MethodAccessFlags.java
new file mode 100644
index 0000000..9b9fca0
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/MethodAccessFlags.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+/**
+ * Valid matches on method access flags and their negations.
+ *
+ * <p>The negated elements make it easier to express the inverse as we cannot use a "not/negation"
+ * operation syntactically.
+ */
+public enum MethodAccessFlags {
+  // General member flags.
+  PUBLIC,
+  NON_PUBLIC,
+  PRIVATE,
+  NON_PRIVATE,
+  PROTECTED,
+  NON_PROTECTED,
+  PACKAGE_PRIVATE,
+  NON_PACKAGE_PRIVATE,
+  STATIC,
+  NON_STATIC,
+  FINAL,
+  NON_FINAL,
+  SYNTHETIC,
+  NON_SYNTHETIC,
+  // Method specific flags.
+  SYNCHRONIZED,
+  NON_SYNCHRONIZED,
+  BRIDGE,
+  NON_BRIDGE,
+  // VARARGS - No PG parser support
+  NATIVE,
+  NON_NATIVE,
+  ABSTRACT,
+  NON_ABSTRACT,
+  STRICT_FP,
+  NON_STRICT_FP
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/StringPattern.java b/src/keepanno/java/androidx/annotation/keep/StringPattern.java
new file mode 100644
index 0000000..0a0d803
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/StringPattern.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A pattern structure for matching strings.
+ *
+ * <p>If no properties are set, the default pattern matches any string.
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface StringPattern {
+
+  /**
+   * Exact string content.
+   *
+   * <p>For example, {@code "foo"} or {@code "java.lang.String"}.
+   *
+   * <p>Mutually exclusive with the following other properties defining string-exact-pattern:
+   *
+   * <ul>
+   *   <li>startsWith
+   *   <li>endsWith
+   * </ul>
+   */
+  String exact() default "";
+
+  /**
+   * Matches strings beginning with the given prefix.
+   *
+   * <p>For example, {@code "get"} to match strings such as {@code "getMyValue"}.
+   *
+   * <p>Mutually exclusive with the property `exact` also defining string-prefix-pattern.
+   */
+  String startsWith() default "";
+
+  /**
+   * Matches strings ending with the given suffix.
+   *
+   * <p>For example, {@code "Setter"} to match strings such as {@code "myValueSetter"}.
+   *
+   * <p>Mutually exclusive with the property `exact` also defining string-suffix-pattern.
+   */
+  String endsWith() default "";
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/TypePattern.java b/src/keepanno/java/androidx/annotation/keep/TypePattern.java
new file mode 100644
index 0000000..71b41aa
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/TypePattern.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A pattern structure for matching types.
+ *
+ * <p>If no properties are set, the default pattern matches any type.
+ *
+ * <p>All properties on this annotation are mutually exclusive.
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface TypePattern {
+
+  /**
+   * Exact type name as a string.
+   *
+   * <p>For example, {@code "long"} or {@code "java.lang.String"}.
+   *
+   * <p>Mutually exclusive with the following other properties defining type-pattern:
+   *
+   * <ul>
+   *   <li>constant
+   *   <li>classNamePattern
+   *   <li>instanceOfPattern
+   * </ul>
+   */
+  String name() default "";
+
+  /**
+   * Exact type from a class constant.
+   *
+   * <p>For example, {@code String.class}.
+   *
+   * <p>Mutually exclusive with the following other properties defining type-pattern:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>classNamePattern
+   *   <li>instanceOfPattern
+   * </ul>
+   */
+  Class<?> constant() default Object.class;
+
+  /**
+   * Classes matching the class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining type-pattern:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>constant
+   *   <li>instanceOfPattern
+   * </ul>
+   */
+  ClassNamePattern classNamePattern() default @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the instance-of with a pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining type-pattern:
+   *
+   * <ul>
+   *   <li>name
+   *   <li>constant
+   *   <li>classNamePattern
+   * </ul>
+   *
+   * @return The pattern that defines what instance-of the class must be.
+   */
+  InstanceOfPattern instanceOfPattern() default @InstanceOfPattern();
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/UsedByNative.java b/src/keepanno/java/androidx/annotation/keep/UsedByNative.java
new file mode 100644
index 0000000..955bc95
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/UsedByNative.java
@@ -0,0 +1,571 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation to mark a class, field or method as being accessed from native code via JNI.
+ *
+ * <p>Note: Before using this annotation, consider if instead you can annotate the code that is
+ * doing reflection with {@link UsesReflection}. Annotating the reflecting code is generally more
+ * clear and maintainable, and it also naturally gives rise to edges that describe just the
+ * reflected aspects of the program. The {@link UsedByReflection} annotation is suitable for cases
+ * where the reflecting code is not under user control, or in migrating away from rules.
+ *
+ * <p>When a class is annotated, member patterns can be used to define which members are to be kept.
+ * When no member patterns are specified the default pattern is to match just the class.
+ *
+ * <p>When a member is annotated, the member patterns cannot be used as the annotated member itself
+ * fully defines the item to be kept (i.e., itself).
+ */
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Retention(RetentionPolicy.CLASS)
+public @interface UsedByNative {
+
+  /**
+   * Optional description to document the reason for this annotation.
+   *
+   * @return The descriptive message. Defaults to no description.
+   */
+  String description() default "";
+
+  /**
+   * Conditions that should be satisfied for the annotation to be in effect.
+   *
+   * @return The list of preconditions. Defaults to no conditions, thus trivially/unconditionally
+   *     satisfied.
+   */
+  KeepCondition[] preconditions() default {};
+
+  /**
+   * Additional targets to be kept in addition to the annotated class/members.
+   *
+   * @return List of additional target consequences. Defaults to no additional target consequences.
+   */
+  KeepTarget[] additionalTargets() default {};
+
+  /**
+   * Specify the kind of this item pattern.
+   *
+   * <p>If unspecified the default kind depends on the annotated item.
+   *
+   * <p>When annotating a class the default kind is:
+   *
+   * <ul>
+   *   <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined;
+   *   <li>{@link KeepItemKind#CLASS_AND_METHODS} if method patterns are defined;
+   *   <li>{@link KeepItemKind#CLASS_AND_FIELDS} if field patterns are defined;
+   *   <li>{@link KeepItemKind#CLASS_AND_MEMBERS} otherwise.
+   * </ul>
+   *
+   * <p>When annotating a method the default kind is: {@link KeepItemKind#ONLY_METHODS}
+   *
+   * <p>When annotating a field the default kind is: {@link KeepItemKind#ONLY_FIELDS}
+   *
+   * <p>It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member.
+   *
+   * @return The kind for this pattern.
+   */
+  KeepItemKind kind() default KeepItemKind.DEFAULT;
+
+  /**
+   * Define the usage constraints of the target.
+   *
+   * <p>The specified constraints must remain valid for the target.
+   *
+   * <p>The default constraints depend on the kind of the target. For all targets the default
+   * constraints include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#LOOKUP}
+   *   <li>{@link KeepConstraint#NAME}
+   *   <li>{@link KeepConstraint#VISIBILITY_RELAX}
+   * </ul>
+   *
+   * <p>For classes the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#CLASS_INSTANTIATE}
+   * </ul>
+   *
+   * <p>For methods the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#METHOD_INVOKE}
+   * </ul>
+   *
+   * <p>For fields the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#FIELD_GET}
+   *   <li>{@link KeepConstraint#FIELD_SET}
+   * </ul>
+   *
+   * <p>Mutually exclusive with the property `constraintAdditions` also defining constraints.
+   *
+   * @return Usage constraints for the target.
+   */
+  KeepConstraint[] constraints() default {};
+
+  /**
+   * Add additional usage constraints of the target.
+   *
+   * <p>The specified constraints must remain valid for the target in addition to the default
+   * constraints.
+   *
+   * <p>The default constraints are documented in {@link #constraints}
+   *
+   * <p>Mutually exclusive with the property `constraints` also defining constraints.
+   *
+   * @return Additional usage constraints for the target.
+   */
+  KeepConstraint[] constraintAdditions() default {};
+
+  /**
+   * Patterns for annotations that must remain on the item.
+   *
+   * <p>The annotations matching any of the patterns must remain on the item if the annotation types
+   * remain in the program.
+   *
+   * <p>Note that if the annotation types themselves are unused/removed, then their references on
+   * the item will be removed too. If the annotation types themselves are used reflectively then
+   * they too need a keep annotation or rule to ensure they remain in the program.
+   *
+   * <p>By default no annotation patterns are defined and no annotations are required to remain.
+   *
+   * @return Annotation patterns
+   */
+  AnnotationPattern[] constrainAnnotations() default {};
+
+  /**
+   * Define the member-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassConstant
+   *   <li>memberAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String memberAnnotatedByClassName() default "";
+
+  /**
+   * Define the member-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> memberAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the member-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern memberAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * @return The member access-flag constraints that must be met.
+   */
+  MemberAccessFlags[] memberAccess() default {};
+
+  /**
+   * Define the method-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassConstant
+   *   <li>methodAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String methodAnnotatedByClassName() default "";
+
+  /**
+   * Define the method-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> methodAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the method-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern methodAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the method-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * method-access flags.
+   *
+   * @return The method access-flag constraints that must be met.
+   */
+  MethodAccessFlags[] methodAccess() default {};
+
+  /**
+   * Define the method-name pattern by an exact method name.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the property `methodNamePattern` also defining method-name.
+   *
+   * @return The exact method name of the method.
+   */
+  String methodName() default "";
+
+  /**
+   * Define the method-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the property `methodName` also defining method-name.
+   *
+   * @return The string pattern of the method name.
+   */
+  StringPattern methodNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the method return-type pattern by a fully qualified type or 'void'.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnTypeConstant
+   *   <li>methodReturnTypePattern
+   * </ul>
+   *
+   * @return The qualified type name of the method return type.
+   */
+  String methodReturnType() default "";
+
+  /**
+   * Define the method return-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypePattern
+   * </ul>
+   *
+   * @return A class constant denoting the type of the method return type.
+   */
+  Class<?> methodReturnTypeConstant() default Object.class;
+
+  /**
+   * Define the method return-type pattern by a type pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypeConstant
+   * </ul>
+   *
+   * @return The pattern of the method return type.
+   */
+  TypePattern methodReturnTypePattern() default @TypePattern(name = "");
+
+  /**
+   * Define the method parameters pattern by a list of fully qualified types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
+   *
+   * @return The list of qualified type names of the method parameters.
+   */
+  String[] methodParameters() default {""};
+
+  /**
+   * Define the method parameters pattern by a list of patterns on types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the property `methodParameters` also defining parameters.
+   *
+   * @return The list of type patterns for the method parameters.
+   */
+  TypePattern[] methodParameterTypePatterns() default {@TypePattern(name = "")};
+
+  /**
+   * Define the field-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassConstant
+   *   <li>fieldAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String fieldAnnotatedByClassName() default "";
+
+  /**
+   * Define the field-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> fieldAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the field-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern fieldAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the field-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any
+   * field-access flags.
+   *
+   * @return The field access-flag constraints that must be met.
+   */
+  FieldAccessFlags[] fieldAccess() default {};
+
+  /**
+   * Define the field-name pattern by an exact field name.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+   *
+   * @return The exact field name of the field.
+   */
+  String fieldName() default "";
+
+  /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldName` also defining field-name.
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the field-type pattern by a fully qualified type.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldTypeConstant
+   *   <li>fieldTypePattern
+   * </ul>
+   *
+   * @return The qualified type name for the field type.
+   */
+  String fieldType() default "";
+
+  /**
+   * Define the field-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypePattern
+   * </ul>
+   *
+   * @return The class constant for the field type.
+   */
+  Class<?> fieldTypeConstant() default Object.class;
+
+  /**
+   * Define the field-type pattern by a pattern on types.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypeConstant
+   * </ul>
+   *
+   * @return The type pattern for the field type.
+   */
+  TypePattern fieldTypePattern() default @TypePattern(name = "");
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/UsedByReflection.java b/src/keepanno/java/androidx/annotation/keep/UsedByReflection.java
new file mode 100644
index 0000000..7cf8b09
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/UsedByReflection.java
@@ -0,0 +1,571 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation to mark a class, field or method as being accessed reflectively.
+ *
+ * <p>Note: Before using this annotation, consider if instead you can annotate the code that is
+ * doing reflection with {@link UsesReflection}. Annotating the reflecting code is generally more
+ * clear and maintainable, and it also naturally gives rise to edges that describe just the
+ * reflected aspects of the program. The {@link UsedByReflection} annotation is suitable for cases
+ * where the reflecting code is not under user control, or in migrating away from rules.
+ *
+ * <p>When a class is annotated, member patterns can be used to define which members are to be kept.
+ * When no member patterns are specified the default pattern is to match just the class.
+ *
+ * <p>When a member is annotated, the member patterns cannot be used as the annotated member itself
+ * fully defines the item to be kept (i.e., itself).
+ */
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Retention(RetentionPolicy.CLASS)
+public @interface UsedByReflection {
+
+  /**
+   * Optional description to document the reason for this annotation.
+   *
+   * @return The descriptive message. Defaults to no description.
+   */
+  String description() default "";
+
+  /**
+   * Conditions that should be satisfied for the annotation to be in effect.
+   *
+   * @return The list of preconditions. Defaults to no conditions, thus trivially/unconditionally
+   *     satisfied.
+   */
+  KeepCondition[] preconditions() default {};
+
+  /**
+   * Additional targets to be kept in addition to the annotated class/members.
+   *
+   * @return List of additional target consequences. Defaults to no additional target consequences.
+   */
+  KeepTarget[] additionalTargets() default {};
+
+  /**
+   * Specify the kind of this item pattern.
+   *
+   * <p>If unspecified the default kind depends on the annotated item.
+   *
+   * <p>When annotating a class the default kind is:
+   *
+   * <ul>
+   *   <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined;
+   *   <li>{@link KeepItemKind#CLASS_AND_METHODS} if method patterns are defined;
+   *   <li>{@link KeepItemKind#CLASS_AND_FIELDS} if field patterns are defined;
+   *   <li>{@link KeepItemKind#CLASS_AND_MEMBERS} otherwise.
+   * </ul>
+   *
+   * <p>When annotating a method the default kind is: {@link KeepItemKind#ONLY_METHODS}
+   *
+   * <p>When annotating a field the default kind is: {@link KeepItemKind#ONLY_FIELDS}
+   *
+   * <p>It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member.
+   *
+   * @return The kind for this pattern.
+   */
+  KeepItemKind kind() default KeepItemKind.DEFAULT;
+
+  /**
+   * Define the usage constraints of the target.
+   *
+   * <p>The specified constraints must remain valid for the target.
+   *
+   * <p>The default constraints depend on the kind of the target. For all targets the default
+   * constraints include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#LOOKUP}
+   *   <li>{@link KeepConstraint#NAME}
+   *   <li>{@link KeepConstraint#VISIBILITY_RELAX}
+   * </ul>
+   *
+   * <p>For classes the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#CLASS_INSTANTIATE}
+   * </ul>
+   *
+   * <p>For methods the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#METHOD_INVOKE}
+   * </ul>
+   *
+   * <p>For fields the default constraints also include:
+   *
+   * <ul>
+   *   <li>{@link KeepConstraint#FIELD_GET}
+   *   <li>{@link KeepConstraint#FIELD_SET}
+   * </ul>
+   *
+   * <p>Mutually exclusive with the property `constraintAdditions` also defining constraints.
+   *
+   * @return Usage constraints for the target.
+   */
+  KeepConstraint[] constraints() default {};
+
+  /**
+   * Add additional usage constraints of the target.
+   *
+   * <p>The specified constraints must remain valid for the target in addition to the default
+   * constraints.
+   *
+   * <p>The default constraints are documented in {@link #constraints}
+   *
+   * <p>Mutually exclusive with the property `constraints` also defining constraints.
+   *
+   * @return Additional usage constraints for the target.
+   */
+  KeepConstraint[] constraintAdditions() default {};
+
+  /**
+   * Patterns for annotations that must remain on the item.
+   *
+   * <p>The annotations matching any of the patterns must remain on the item if the annotation types
+   * remain in the program.
+   *
+   * <p>Note that if the annotation types themselves are unused/removed, then their references on
+   * the item will be removed too. If the annotation types themselves are used reflectively then
+   * they too need a keep annotation or rule to ensure they remain in the program.
+   *
+   * <p>By default no annotation patterns are defined and no annotations are required to remain.
+   *
+   * @return Annotation patterns
+   */
+  AnnotationPattern[] constrainAnnotations() default {};
+
+  /**
+   * Define the member-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassConstant
+   *   <li>memberAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String memberAnnotatedByClassName() default "";
+
+  /**
+   * Define the member-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> memberAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the member-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining member-annotated-by:
+   *
+   * <ul>
+   *   <li>memberAnnotatedByClassName
+   *   <li>memberAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * <p>If none are specified the default is to match any member regardless of what the member is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern memberAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the member-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field and method properties as use restricts the match to both
+   * types of members.
+   *
+   * @return The member access-flag constraints that must be met.
+   */
+  MemberAccessFlags[] memberAccess() default {};
+
+  /**
+   * Define the method-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassConstant
+   *   <li>methodAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String methodAnnotatedByClassName() default "";
+
+  /**
+   * Define the method-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> methodAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the method-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining method-annotated-by:
+   *
+   * <ul>
+   *   <li>methodAnnotatedByClassName
+   *   <li>methodAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none are specified the default is to match any method regardless of what the method is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern methodAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the method-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * method-access flags.
+   *
+   * @return The method access-flag constraints that must be met.
+   */
+  MethodAccessFlags[] methodAccess() default {};
+
+  /**
+   * Define the method-name pattern by an exact method name.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the property `methodNamePattern` also defining method-name.
+   *
+   * @return The exact method name of the method.
+   */
+  String methodName() default "";
+
+  /**
+   * Define the method-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any method
+   * name.
+   *
+   * <p>Mutually exclusive with the property `methodName` also defining method-name.
+   *
+   * @return The string pattern of the method name.
+   */
+  StringPattern methodNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the method return-type pattern by a fully qualified type or 'void'.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnTypeConstant
+   *   <li>methodReturnTypePattern
+   * </ul>
+   *
+   * @return The qualified type name of the method return type.
+   */
+  String methodReturnType() default "";
+
+  /**
+   * Define the method return-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypePattern
+   * </ul>
+   *
+   * @return A class constant denoting the type of the method return type.
+   */
+  Class<?> methodReturnTypeConstant() default Object.class;
+
+  /**
+   * Define the method return-type pattern by a type pattern.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any return
+   * type.
+   *
+   * <p>Mutually exclusive with the following other properties defining return-type:
+   *
+   * <ul>
+   *   <li>methodReturnType
+   *   <li>methodReturnTypeConstant
+   * </ul>
+   *
+   * @return The pattern of the method return type.
+   */
+  TypePattern methodReturnTypePattern() default @TypePattern(name = "");
+
+  /**
+   * Define the method parameters pattern by a list of fully qualified types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
+   *
+   * @return The list of qualified type names of the method parameters.
+   */
+  String[] methodParameters() default {""};
+
+  /**
+   * Define the method parameters pattern by a list of patterns on types.
+   *
+   * <p>Mutually exclusive with all field properties.
+   *
+   * <p>If none, and other properties define this item as a method, the default matches any
+   * parameters.
+   *
+   * <p>Mutually exclusive with the property `methodParameters` also defining parameters.
+   *
+   * @return The list of type patterns for the method parameters.
+   */
+  TypePattern[] methodParameterTypePatterns() default {@TypePattern(name = "")};
+
+  /**
+   * Define the field-annotated-by pattern by fully qualified class name.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassConstant
+   *   <li>fieldAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The qualified class name that defines the annotation.
+   */
+  String fieldAnnotatedByClassName() default "";
+
+  /**
+   * Define the field-annotated-by pattern by reference to a Class constant.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassNamePattern
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-constant that defines the annotation.
+   */
+  Class<?> fieldAnnotatedByClassConstant() default Object.class;
+
+  /**
+   * Define the field-annotated-by pattern by reference to a class-name pattern.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-annotated-by:
+   *
+   * <ul>
+   *   <li>fieldAnnotatedByClassName
+   *   <li>fieldAnnotatedByClassConstant
+   * </ul>
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none are specified the default is to match any field regardless of what the field is
+   * annotated by.
+   *
+   * @return The class-name pattern that defines the annotation.
+   */
+  ClassNamePattern fieldAnnotatedByClassNamePattern() default
+      @ClassNamePattern(unqualifiedName = "");
+
+  /**
+   * Define the field-access pattern by matching on access flags.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any
+   * field-access flags.
+   *
+   * @return The field access-flag constraints that must be met.
+   */
+  FieldAccessFlags[] fieldAccess() default {};
+
+  /**
+   * Define the field-name pattern by an exact field name.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+   *
+   * @return The exact field name of the field.
+   */
+  String fieldName() default "";
+
+  /**
+   * Define the field-name pattern by a string pattern.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any field
+   * name.
+   *
+   * <p>Mutually exclusive with the property `fieldName` also defining field-name.
+   *
+   * @return The string pattern of the field name.
+   */
+  StringPattern fieldNamePattern() default @StringPattern(exact = "");
+
+  /**
+   * Define the field-type pattern by a fully qualified type.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldTypeConstant
+   *   <li>fieldTypePattern
+   * </ul>
+   *
+   * @return The qualified type name for the field type.
+   */
+  String fieldType() default "";
+
+  /**
+   * Define the field-type pattern by a class constant.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypePattern
+   * </ul>
+   *
+   * @return The class constant for the field type.
+   */
+  Class<?> fieldTypeConstant() default Object.class;
+
+  /**
+   * Define the field-type pattern by a pattern on types.
+   *
+   * <p>Mutually exclusive with all method properties.
+   *
+   * <p>If none, and other properties define this item as a field, the default matches any type.
+   *
+   * <p>Mutually exclusive with the following other properties defining field-type:
+   *
+   * <ul>
+   *   <li>fieldType
+   *   <li>fieldTypeConstant
+   * </ul>
+   *
+   * @return The type pattern for the field type.
+   */
+  TypePattern fieldTypePattern() default @TypePattern(name = "");
+}
diff --git a/src/keepanno/java/androidx/annotation/keep/UsesReflection.java b/src/keepanno/java/androidx/annotation/keep/UsesReflection.java
new file mode 100644
index 0000000..0d7ca88
--- /dev/null
+++ b/src/keepanno/java/androidx/annotation/keep/UsesReflection.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed 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.
+ */
+
+// ***********************************************************************************
+// GENERATED FILE. DO NOT EDIT! See KeepItemAnnotationGenerator.java.
+// ***********************************************************************************
+
+// ***********************************************************************************
+// MAINTAINED AND TESTED IN THE R8 REPO. PLEASE MAKE CHANGES THERE AND REPLICATE.
+// ***********************************************************************************
+
+package androidx.annotation.keep;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation to declare the reflective usages made by a class, method or field.
+ *
+ * <p>The annotation's 'value' is a list of targets to be kept if the annotated item is used. The
+ * annotated item is a precondition for keeping any of the specified targets. Thus, if an annotated
+ * method is determined to be unused by the program, the annotation itself will not be in effect and
+ * the targets will not be kept (assuming nothing else is otherwise keeping them).
+ *
+ * <p>The annotation's 'additionalPreconditions' is optional and can specify additional conditions
+ * that should be satisfied for the annotation to be in effect.
+ *
+ * <p>The translation of the {@link UsesReflection} annotation into a {@link KeepEdge} is as
+ * follows:
+ *
+ * <p>Assume the item of the annotation is denoted by 'CTX' and referred to as its context.
+ *
+ * <pre>
+ * &#64;UsesReflection(value = targets, [additionalPreconditions = preconditions])
+ * ==&gt;
+ * &#64;KeepEdge(
+ *   consequences = targets,
+ *   preconditions = {createConditionFromContext(CTX)} + preconditions
+ * )
+ *
+ * where
+ *   KeepCondition createConditionFromContext(ctx) {
+ *     if (ctx.isClass()) {
+ *       return new KeepCondition(classTypeName = ctx.getClassTypeName());
+ *     }
+ *     if (ctx.isMethod()) {
+ *       return new KeepCondition(
+ *         classTypeName = ctx.getClassTypeName(),
+ *         methodName = ctx.getMethodName(),
+ *         methodReturnType = ctx.getMethodReturnType(),
+ *         methodParameterTypes = ctx.getMethodParameterTypes());
+ *     }
+ *     if (ctx.isField()) {
+ *       return new KeepCondition(
+ *         classTypeName = ctx.getClassTypeName(),
+ *         fieldName = ctx.getFieldName()
+ *         fieldType = ctx.getFieldType());
+ *     }
+ *     // unreachable
+ *   }
+ * </pre>
+ */
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Retention(RetentionPolicy.CLASS)
+public @interface UsesReflection {
+
+  /**
+   * Optional description to document the reason for this annotation.
+   *
+   * @return The descriptive message. Defaults to no description.
+   */
+  String description() default "";
+
+  /**
+   * Consequences that must be kept if the annotation is in effect.
+   *
+   * @return The list of target consequences.
+   */
+  KeepTarget[] value();
+
+  /**
+   * Additional preconditions for the annotation to be in effect.
+   *
+   * @return The list of additional preconditions. Defaults to no additional preconditions.
+   */
+  KeepCondition[] additionalPreconditions() default {};
+}