Java Built-in Annotations: @Override, @Deprecated and More

Su Suriya Ravichandran Updated 18 Nov 2026
13 min read ·Lesson 234 of 306

Java built-in annotations are the annotation types that ship with the JDK in the java.lang and java.lang.annotation packages. Some of them talk to the compiler, such as @Override and @SuppressWarnings. Others, called meta-annotations, describe how other annotations behave, such as @Retention and @Target.

Java Annotations explained what annotations are and how retention works. This lesson walks through every built-in annotation you will meet in everyday Java code, with the exact compiler messages each one produces.


Overview of Java Built-in Annotations

AnnotationPackageApplies toPurpose
@Overridejava.langMethodsCompile error if the method does not override anything
@Deprecatedjava.langAlmost any declarationMarks an API as outdated; callers get warnings
@SuppressWarningsjava.langClasses, methods, fields, variables, parametersHides specific compiler warnings
@SafeVarargsjava.langStatic, final or private methods and constructorsPromises a generic varargs method is safe
@FunctionalInterfacejava.langInterfacesCompile error if the interface is not functional
@Retentionjava.lang.annotationAnnotation typesHow long an annotation is kept
@Targetjava.lang.annotationAnnotation typesWhere an annotation may be placed
@Documentedjava.lang.annotationAnnotation typesShow the annotation in Javadoc
@Inheritedjava.lang.annotationAnnotation typesSubclasses inherit a class-level annotation
@Repeatablejava.lang.annotationAnnotation typesAllow the same annotation more than once

Note: Annotations in java.lang need no import. The meta-annotations live in java.lang.annotation and must be imported.


@Override: Catch Overriding Mistakes

@Override tells the compiler that a method is meant to override a method from a superclass or implement one from an interface. If it does neither, compilation fails.

public class Typo {
    static class Animal {
        String sound() { return "..."; }
    }

    static class Cat extends Animal {
        @Override
        String sounds() {          // typo: "sounds" instead of "sound"
            return "Meow";
        }
    }
}
Typo.java:7: error: method does not override or implement a method from a supertype
        @Override
        ^
1 error

How it works:

  • Without the annotation, sounds() would compile as a new method, and every Cat would still say "...".
  • @Override has SOURCE retention. It is checked by the compiler and then removed, so it costs nothing at runtime.
  • Use it on every overriding method, including toString(), equals() and interface methods.

@Deprecated: Mark Outdated APIs

@Deprecated marks a class, method, field or other declaration that should no longer be used. Since Java 9 it has two elements.

ElementTypeDefaultMeaning
sinceString""The version in which it was deprecated
forRemovalbooleanfalsetrue means it will be deleted in a future version
public class PaymentService {

    public String payWithUpi(double amount) {
        return "UPI payment of Rs. " + amount;
    }

    @Deprecated(since = "3.0")
    public String payWithCheque(double amount) {
        return "Cheque payment of Rs. " + amount;
    }

    @Deprecated(since = "2.4", forRemoval = true)
    public String payWithDemandDraft(double amount) {
        return "DD payment of Rs. " + amount;
    }
}

A caller that uses all three methods:

public class Shop {
    public static void main(String[] args) {
        PaymentService payments = new PaymentService();
        System.out.println(payments.payWithUpi(499.0));
        System.out.println(payments.payWithCheque(1200.0));
        System.out.println(payments.payWithDemandDraft(5000.0));
    }
}

Compile with plain javac Shop.java:

Shop.java:6: warning: [removal] payWithDemandDraft(double) in PaymentService has been deprecated and marked for removal
        System.out.println(payments.payWithDemandDraft(5000.0));
                                   ^
Note: Shop.java uses or overrides a deprecated API.
Note: Recompile with -Xlint:deprecation for details.
1 warning

Output when run:

UPI payment of Rs. 499.0
Cheque payment of Rs. 1200.0
DD payment of Rs. 5000.0

How it works:

  • forRemoval = true produces a full [removal] warning on every compile, because the code will break once the method is deleted.
  • Ordinary deprecation produces only a short note. Add -Xlint:deprecation to see each [deprecation] warning with its line number.
  • Deprecated code still runs normally. The annotation warns; it never blocks.

Note: Always tell users what to use instead. The Javadoc tag @deprecated (lowercase, in a comment) is where you write "Use payWithUpi(double) instead". Use both together: the annotation for tools, the tag for people.


@SuppressWarnings: Hide Specific Compiler Warnings

@SuppressWarnings turns off named compiler warnings for the declaration it is placed on. It is common when working with legacy code that uses raw types. Here is a method compiled with all warnings enabled (-Xlint:all):

import java.util.ArrayList;
import java.util.List;

public class SuppressDemo {

    static List<String> loadNames() {
        List rawList = new ArrayList();      // raw type, as old code often has
        rawList.add("Asha");
        rawList.add("Ravi");
        return rawList;                      // unchecked conversion
    }

    public static void main(String[] args) {
        System.out.println(loadNames());
    }
}
javac -Xlint:all SuppressDemo.java
SuppressDemo.java:7: warning: [rawtypes] found raw type: List
SuppressDemo.java:7: warning: [rawtypes] found raw type: ArrayList
SuppressDemo.java:8: warning: [unchecked] unchecked call to add(E) as a member of the raw type List
SuppressDemo.java:9: warning: [unchecked] unchecked call to add(E) as a member of the raw type List
SuppressDemo.java:10: warning: [unchecked] unchecked conversion
5 warnings

(Each warning also prints the source line; they are shortened here.) Add the annotation to the method and compile again:

    @SuppressWarnings({"rawtypes", "unchecked"})
    static List<String> loadNames() {
        List rawList = new ArrayList();
        rawList.add("Asha");
        rawList.add("Ravi");
        return rawList;
    }

Output of javac -Xlint:all SuppressDemo.java: no warnings. Running the program:

[Asha, Ravi]

Common @SuppressWarnings Names

NameHides warnings about
"unchecked"Unchecked casts and conversions with generics
"rawtypes"Generic types used without type arguments
"deprecation"Use of @Deprecated APIs
"removal"Use of APIs deprecated with forRemoval = true
"unused"Unused variables or methods (used by IDEs)
"serial"Missing serialVersionUID in a Serializable class
"all"Everything (supported by IDEs; avoid it)

How it works:

  • The [rawtypes] and [unchecked] labels in each warning are exactly the names you pass to @SuppressWarnings.
  • The annotation covers only the declaration it sits on. Put it on the smallest scope possible: a local variable or one method, not the whole class, so new problems elsewhere are still reported.

@SafeVarargs: Generic Varargs Without Warnings

A varargs parameter is really an array. When its type is generic, such as T..., Java cannot create a fully typed array, and the compiler warns about possible heap pollution.

import java.util.ArrayList;
import java.util.List;

public class VarargsDemo {

    static <T> List<T> listOf(T... items) {
        List<T> result = new ArrayList<>();
        for (T item : items) {
            result.add(item);
        }
        return result;
    }

    public static void main(String[] args) {
        List<List<String>> batches = listOf(List.of("A", "B"), List.of("C"));
        System.out.println(batches);
    }
}
javac -Xlint:unchecked VarargsDemo.java
VarargsDemo.java:6: warning: [unchecked] Possible heap pollution from parameterized vararg type T
    static <T> List<T> listOf(T... items) {
                                   ^
VarargsDemo.java:15: warning: [unchecked] unchecked generic array creation for varargs parameter of type List<String>[]
        List<List<String>> batches = listOf(List.of("A", "B"), List.of("C"));
                                           ^
2 warnings

The method only reads from the array, so it is safe. Say so with @SafeVarargs:

    @SafeVarargs
    static <T> List<T> listOf(T... items) {
        List<T> result = new ArrayList<>();
        for (T item : items) {
            result.add(item);
        }
        return result;
    }

Both warnings disappear, at the declaration and at every call site. Output:

[[A, B], [C]]

@SafeVarargs is allowed only on methods that cannot be overridden, because an overriding method could break the promise:

public class BadSafe {
    @SafeVarargs
    public <T> void printAll(T... items) {
        for (T item : items) System.out.println(item);
    }
}
BadSafe.java:3: error: Invalid SafeVarargs annotation. Instance method <T>printAll(T...) is neither final nor private.

How it works:

  • Valid places are constructors and static, final or private methods.
  • Use it only when the method never stores anything into the varargs array and never lets the array escape. List.of(...) and Arrays.asList(...) in the JDK are declared this way.

@FunctionalInterface: Guarantee One Abstract Method

A functional interface has exactly one abstract method, which is what makes lambdas possible. @FunctionalInterface asks the compiler to check that rule.

@FunctionalInterface
interface DiscountRule {
    double apply(double price);

    default DiscountRule then(DiscountRule next) {   // default methods are allowed
        return price -> next.apply(apply(price));
    }
}

public class FiDemo {
    public static void main(String[] args) {
        DiscountRule festive = price -> price * 0.90;
        DiscountRule coupon = price -> price - 100;
        System.out.println(festive.then(coupon).apply(2000));
    }
}

Output:

1700.0

Add a second abstract method and the annotation reports it:

@FunctionalInterface
interface PriceRule {
    double apply(double price);

    double reverse(double price);   // a second abstract method
}
BadFi.java:1: error: Unexpected @FunctionalInterface annotation
@FunctionalInterface
^
  PriceRule is not a functional interface
    multiple non-overriding abstract methods found in interface PriceRule
1 error

How it works:

  • 2000 × 0.90 = 1800, then 1800 − 100 = 1700. The then default method chains two rules, and default and static methods do not count against the "one abstract method" rule.
  • Without the annotation, the interface would still work with lambdas. The annotation protects it from someone accidentally adding a second abstract method later, which would break every lambda that uses it.
  • See Java Functional Interfaces for the built-in ones like Function and Predicate.

Meta-Annotations: @Retention, @Target, @Documented

Meta-annotations go on annotation declarations (@interface) to configure them.

Meta-annotationValuesDefault if omitted
@RetentionRetentionPolicy.SOURCE, CLASS, RUNTIMECLASS (not visible to reflection)
@TargetElementType.TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_PARAMETER, TYPE_USE, MODULE, RECORD_COMPONENTAny declaration context
@DocumentednoneAnnotation is not listed in Javadoc

@Target enforces placement at compile time:

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@interface Timed { }

@Timed                      // not allowed: Timed is only for methods
public class TargetErr { }
TargetErr.java:7: error: annotation interface not applicable to this kind of declaration
@Timed                      // not allowed: Timed is only for methods
^
1 error

How it works:

  • @Target(ElementType.METHOD) lists the only place @Timed may appear. Pass several values in braces, for example @Target({ElementType.TYPE, ElementType.METHOD}).
  • @Documented makes Javadoc show the annotation on each documented element. @Deprecated is documented, which is why deprecated methods display it in API docs.
  • The next lesson, Java Annotation Targets, covers every ElementType in detail.

@Inherited: Class Annotations Passed to Subclasses

By default, an annotation on a class is not visible on its subclasses. @Inherited changes that for class-level annotations.

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Audited { }

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Cached { }

@Audited
@Cached
class BaseRepository { }

class OrderRepository extends BaseRepository { }

public class MetaDemo {
    public static void main(String[] args) {
        for (Class<?> type : new Class<?>[] {BaseRepository.class, OrderRepository.class}) {
            System.out.printf("%-16s audited=%-5b cached=%b%n", type.getSimpleName(),
                    type.isAnnotationPresent(Audited.class),
                    type.isAnnotationPresent(Cached.class));
        }
    }
}

Output:

BaseRepository   audited=true  cached=true
OrderRepository  audited=true  cached=false

How it works:

  • OrderRepository has no annotations of its own, yet it reports audited=true because @Audited is @Inherited.
  • @Cached is not inherited, so the subclass reports false.
  • @Inherited works only for annotations on classes and only through extends. It has no effect on methods, fields or interfaces.

@Repeatable: Use the Same Annotation Twice

Normally an annotation may appear only once per declaration. @Repeatable (Java 8+) allows repeats. It needs a container annotation whose value() is an array of the repeatable type.

import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Arrays;

@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Schedules.class)            // the container that holds repeated values
@interface Schedule {
    String day();
    String time();
}

@Retention(RetentionPolicy.RUNTIME)
@interface Schedules {
    Schedule[] value();
}

public class RepeatDemo {

    @Schedule(day = "MON", time = "09:00")
    @Schedule(day = "THU", time = "18:30")
    static void backupDatabase() { }

    public static void main(String[] args) throws NoSuchMethodException {
        var method = RepeatDemo.class.getDeclaredMethod("backupDatabase");
        for (Schedule schedule : method.getAnnotationsByType(Schedule.class)) {
            System.out.println("Backup on " + schedule.day() + " at " + schedule.time());
        }
        System.out.println("getAnnotation(Schedule) = " + method.getAnnotation(Schedule.class));
        System.out.println("Stored as: " + Arrays.toString(method.getAnnotations()));
    }
}

Output:

Backup on MON at 09:00
Backup on THU at 18:30
getAnnotation(Schedule) = null
Stored as: [@Schedules({@Schedule(day="MON", time="09:00"), @Schedule(day="THU", time="18:30")})]

How it works:

  • The compiler silently wraps the two @Schedule annotations into one @Schedules container, as the last line shows.
  • That is why getAnnotation(Schedule.class) returns null. Always read repeatable annotations with getAnnotationsByType(...), which unwraps the container for you.
  • The container must have the same or longer retention and a compatible target.

Real-World Example: A Notification Channel Registry

This example uses every built-in annotation from the lesson in one small program. A notification center scans its channels, reads the owning team (inherited), the supported regions (repeatable), and skips channels that are marked for removal.

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

// ---- annotation types built with meta-annotations ----
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface OwnedBy {
    String value();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Repeatable(Regions.class)
@interface Region {
    String value();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Regions {
    Region[] value();
}

// ---- the channel contract ----
@FunctionalInterface
interface Channel {
    String send(String user, String message);
}

@OwnedBy("notifications-team")
abstract class BaseChannel implements Channel {
    @Override
    public String toString() {
        return getClass().getSimpleName();
    }
}

@Region("IN")
@Region("AE")
class SmsChannel extends BaseChannel {
    @Override
    public String send(String user, String message) {
        return "SMS to " + user + ": " + message;
    }
}

@Region("GLOBAL")
class EmailChannel extends BaseChannel {
    @Override
    public String send(String user, String message) {
        return "Email to " + user + ": " + message;
    }
}

@Deprecated(since = "5.0", forRemoval = true)
@Region("IN")
class FaxChannel extends BaseChannel {
    @Override
    public String send(String user, String message) {
        return "Fax to " + user + ": " + message;
    }
}

public class NotificationCenter {

    @SafeVarargs
    static <T> List<T> listOf(T... items) {
        List<T> result = new ArrayList<>();
        for (T item : items) {
            result.add(item);
        }
        return result;
    }

    @SuppressWarnings("removal")          // we use FaxChannel on purpose, to report it
    public static void main(String[] args) {
        List<BaseChannel> channels = listOf(new SmsChannel(), new EmailChannel(), new FaxChannel());

        for (BaseChannel channel : channels) {
            Class<?> type = channel.getClass();
            OwnedBy owner = type.getAnnotation(OwnedBy.class);              // inherited
            List<String> regions = Arrays.stream(type.getAnnotationsByType(Region.class))
                    .map(Region::value)
                    .toList();
            Deprecated deprecated = type.getAnnotation(Deprecated.class);

            System.out.printf("%-13s owner=%s regions=%s%n", channel, owner.value(), regions);
            if (deprecated != null && deprecated.forRemoval()) {
                System.out.println("  SKIPPED: deprecated since " + deprecated.since() + ", marked for removal");
                continue;
            }
            System.out.println("  " + channel.send("Asha", "Your order ORD-1001 has shipped"));
        }

        Channel console = (user, message) -> "Console to " + user + ": " + message; // lambda works
        System.out.println(console.send("Ravi", "Welcome to GOCOURSE"));
    }
}
javac -Xlint:all NotificationCenter.java
java NotificationCenter

Output (the compile step prints no warnings):

SmsChannel    owner=notifications-team regions=[IN, AE]
  SMS to Asha: Your order ORD-1001 has shipped
EmailChannel  owner=notifications-team regions=[GLOBAL]
  Email to Asha: Your order ORD-1001 has shipped
FaxChannel    owner=notifications-team regions=[IN]
  SKIPPED: deprecated since 5.0, marked for removal
Console to Ravi: Welcome to GOCOURSE

How it works:

  1. @OwnedBy with @Inherited. It is written once on BaseChannel, yet every subclass returns it from getAnnotation. @Documented would also list it in the generated Javadoc.
  2. @Region with @Repeatable. SmsChannel declares two regions. getAnnotationsByType returns both, and a stream maps them to [IN, AE].
  3. @Deprecated(forRemoval = true). The registry reads it at runtime and skips FaxChannel, while the compiler would warn anyone who uses it.
  4. @SuppressWarnings("removal"). The program creates a FaxChannel on purpose, so the [removal] warning is suppressed on main only. Remove the annotation and javac prints warning: [removal] FaxChannel in unnamed package has been deprecated and marked for removal.
  5. @SafeVarargs. listOf is static and only reads its array, so -Xlint:all stays silent.
  6. @FunctionalInterface and @Override. Channel has exactly one abstract method, so the console lambda compiles, and every send implementation is checked by @Override.

In Java Custom Annotations you will design annotation types like @OwnedBy and @Region from scratch, including elements, defaults and runtime processing.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about Java Built-in Annotations: @Override, @Deprecated and More and get answers drawn from it.

Signed-in readers only.