/** Returns the types that are interfaces implemented by this type. */
    public TypeSet interfaces() {
      return new InterfaceSet(this);
    }

    /** Returns the types that are classes. */
    public TypeSet classes() {
      return new ClassSet();
    }

    @Override
    protected Set<TypeToken<? super T>> delegate() {
      ImmutableSet<TypeToken<? super T>> filteredTypes = types;

        super(message);
        this.repository = repository;
    }

    /**
     * Gets the repository that causes this error (if any).
     *
     * @return The repository that causes this error or {@code null} if not known.
     */
    public Repository getRepository() {
        return repository;
    }

```

////

Using `str | None` instead of just `str` will let the editor help you detect errors where you could be assuming that a value is always a `str`, when it could actually be `None` too.

### Classes as types { #classes-as-types }

You can also declare a class as the type of a variable.

Let's say you have a class `Person`, with a name:

{* ../../docs_src/python_types/tutorial010_py310.py hl[1:3] *}

    }

    // ========== Security Tests ==========

    /**
     * Security test: Verify that unregistered classes are rejected during serialization.
     * This test ensures that the Kryo registration requirement is working correctly.
     * Unregistered classes should throw an exception to prevent potential RCE attacks.
     */
    @Test
    public void test_security_unregisteredClassRejected() {

	FieldsWithDefaultDBValue  []*Field // fields with default value assigned by database
	Relationships             Relationships
	CreateClauses             []clause.Interface
	QueryClauses              []clause.Interface
	UpdateClauses             []clause.Interface
	DeleteClauses             []clause.Interface
	BeforeCreate, AfterCreate bool
	BeforeUpdate, AfterUpdate bool
	BeforeDelete, AfterDelete bool
	BeforeSave, AfterSave     bool

   * throws} clause: Java forces us to handle an arbitrary {@link Throwable} from that method,
   * rather than just the {@link RuntimeException} or {@link Error} that should be possible. (And in
   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by

   * throws} clause: Java forces us to handle an arbitrary {@link Throwable} from that method,
   * rather than just the {@link RuntimeException} or {@link Error} that should be possible. (And in
   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by

  <name>Lifecycle</name>
  <description>
    Configuration of custom lifecycle mappings for the plugin, as generally stored in
    {@code META-INF/maven/lifecycle.xml} in a plugin's jar artifact.
  </description>
  <classes>
    <class rootElement="true" xml.tagName="lifecycles" xsd.compositor="sequence">
      <name>LifecycleConfiguration</name>
      <version>1.0.0+</version>

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.io;

/**
 * Interface for handlers that process classes.
 *
 * @author koichik
 */
public interface ClassHandler {

    /**
     * Processes a class.
     *
     * @param packageName the package name
     * @param shortClassName the simple class name

 * limitations under the License.
 */

package com.google.common;

import com.google.gwt.core.client.EntryPoint;

/**
 * A dummy entry point to convince Maven to compile our classes.
 *
 * @author Chris Povirk
 */
public class ForceGuavaCompilationEntryPoint implements EntryPoint {
  @Override
  public void onModuleLoad() {}