}

    // #app_customize you can customize the action hook
    /**
     * Hook method called before action processing.
     * This method can be overridden by subclasses to customize behavior.
     *
     * @param runtime the action runtime context
     * @return the action response, or null to continue with normal processing
     */
    @Override

And tools will also be happy because both `RedirectResponse` and `JSONResponse` are subclasses of `Response`, so the type annotation is correct.

### Annotate a Response Subclass { #annotate-a-response-subclass }

You can also use a subclass of `Response` in the type annotation:

  /** Constructor for use by subclasses. */
  protected Converter() {
    this(true);
  }

  /** Constructor used only by {@code LegacyConverter} to suspend automatic null-handling. */
  Converter(boolean handleNullAutomatically) {
    this.handleNullAutomatically = handleNullAutomatically;
  }

  // SPI methods (what subclasses must implement)

  /**

        assertTrue(testTransformer.getName().startsWith("thread"));
    }

    /**
     * Test inheritance behavior
     */
    public void test_inheritanceBehavior() {
        // Test that subclasses inherit name management
        TestTransformer transformer1 = new TestTransformer();
        NameTrackingTransformer transformer2 = new NameTrackingTransformer();

        transformer1.setName("transformer1");

      } catch (ClassCastException wastNotComparableToOurType) {
        return false;
      }
    }
    return false;
  }

  // Prevent "missing hashCode" warning by explicitly forcing subclasses implement it
  @Override
  public abstract int hashCode();

  /*
   * The implementation neither produces nor consumes any non-null instance of type C, so
   * casting the type parameter is safe.
   */

   *
   * @author Luke Sandberg
   * @since 15.0 (present as an interface in 13.0)
   */
  abstract class Listener {
    /** Constructor for use by subclasses. */
    public Listener() {}

    /**
     * Called when the service transitions from {@linkplain State#NEW NEW} to {@linkplain

    as a dependency. All other OAuth2 classes inherit from it and customize it for
    each OAuth2 flow.

    You normally would not create a new class inheriting from it but use one of the
    existing subclasses, and maybe compose them if you want to support multiple flows.

    Read more about it in the
    [FastAPI docs for Security](https://fastapi.tiangolo.com/tutorial/security/).
    """

    def __init__(

       * more information, see the comments in that class.
       *
       * We already know that that's how it behaves, and subclasses of Converter can't change that
       * behavior. So there's no sense in making all subclass authors exclude the method from any
       * NullPointerTester tests that they have.
       */
      ignoredMembers.add(Converter.class.getMethod("apply", Object.class));

import junit.framework.TestCase;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tests representing the contract of {@link Map}. Concrete subclasses of this base class test
 * conformance of concrete {@link Map} subclasses to that contract.
 *
 * @param <K> the type of keys used by the maps under test
 * @param <V> the type of mapped values used the maps under test
 * @author George van den Driessche
 */

              <exclude>%regex[.*Tester.class]</exclude>
              <!-- Anonymous TestCase subclasses in GeneratedMonitorTest -->
              <exclude>%regex[.*[$]\d+.class]</exclude>
            </excludes>
            <redirectTestOutputToFile>true</redirectTestOutputToFile>
            <runOrder>alphabetical</runOrder>