This is preferred:

```groovy
public interface NewThing {
    Property<String> getSomeProperty()
}
```

This is acceptable:

```groovy
public interface NewThing {
    Property<String> getSomeProperty()
}

abstract class DefaultNewThing implements NewThing {

 * such as {@code Set} or {@code List}, so that the implementation of {@code equals} can cast the
 * object being tested for equality to the custom interface. {@code ForwardingObject} implements no
 * such custom interfaces directly; they are implemented only in subclasses. Therefore, forwarding
 * {@code equals} would break symmetry, as the forwarding object might consider itself equal to the

   * @throws UnsupportedOperationException if backward conversion is not implemented; this should be
   *     very rare. Note that if backward conversion is not only unimplemented but
   *     unimplement<i>able</i> (for example, consider a {@code Converter<Chicken, ChickenNugget>}),
   *     then this is not logically a {@code Converter} at all, and should just implement {@link
   *     Function}.
   */
  @ForOverride

import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * This class provides a skeletal implementation of {@link ValueGraph}. It is recommended to extend
 * this class rather than implement {@link ValueGraph} directly.
 *
 * <p>The methods implemented in this class should not be overridden unless the subclass admits a
 * more efficient implementation.
 *
 * @author James Sexton
 * @param <N> Node parameter type

		StartTime:      time.Now().UTC(),
	}
}

// ErrNotImplemented when a functionality is not implemented
var ErrNotImplemented = errors.New("not implemented")

// ReadFrom implements support for calling internal io.ReaderFrom implementations
// returns an error if the underlying ResponseWriter does not implement io.ReaderFrom
func (lrw *ResponseRecorder) ReadFrom(r io.Reader) (int64, error) {
	if lrw.ReaderFrom != nil {

   * @throws IllegalArgumentException if {@code count} is negative
   * @throws NullPointerException if {@code element} is null and this implementation does not permit
   *     null elements. Note that if {@code count} is zero, the implementor may optionally return
   *     zero instead.
   */
  @CanIgnoreReturnValue
  int setCount(@ParametricNullness E element, int count);

  /**

    * Si on n'utilisait pas FastAPI mais directement Starlette (ou un outil équivalent comme Sanic, Flask, Responder, etc) il faudrait implémenter la validation des données et la sérialisation par nous-même. Le résultat serait donc le même dans les deux cas mais du travail supplémentaire serait à réaliser avec Starlette, surtout en considérant que la validation des données et la sérialisation...

            return compressLZ77Huffman(data, offset, length);

        case COMPRESSION_LZNT1:
            throw new CIFSException("LZNT1 compression not yet implemented");

        case COMPRESSION_PATTERN_V1:
            throw new CIFSException("Pattern_V1 compression not yet implemented");

        default:
            throw new CIFSException("Unknown compression algorithm: " + algorithm);
        }
    }

    @Override

 * <p>
 * SPI services are typically registered in {@code META-INF/services/} files corresponding to
 * the specific service interface being implemented.
 * <p>
 * All SPI services should be annotated with {@link Consumer} to indicate they are meant to be
 * implemented by plugins and extensions rather than used by them.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer

  public static final class UnsupportedLoadingOperationException
      extends UnsupportedOperationException {
    // Package-private because this should only be thrown by loadAll() when it is not overridden.
    // Cache implementors may want to catch it but should not need to be able to throw it.
    UnsupportedLoadingOperationException() {}
  }

  /**