* @param object the object to cast
     * @return object cast to type
     * @throws PACDecodingException if types are incompatible
     */
    public static <T> T as(final Class<T> type, final Object object) throws PACDecodingException {
        if (!type.isInstance(object)) {
            throw new PACDecodingException("Incompatible object types " + type + " " + object.getClass());
        }

        return type.cast(object);
    }

    /**

        <state type="buildPinned" enabled="false" />
        <state type="buildUnpinned" enabled="false" />
      </states>
      <build-types enabled-for-all="false" enabled-for-subprojects="false">
        <build-type id="bt270451" />
      </build-types>
    </webhook>
    <webhook url="https://gradle-bot.grdev.net/teamcity" enabled="true" template="legacy-tailored-json">
      <states>

    /**
     * Returns all methods that are applicable to actual argument types.
     *
     * @param methods list of all candidate methods
     * @param classes the actual types of the arguments
     * @return a list that contains only applicable methods (number of
     *         formal and actual arguments matches, and argument types are assignable
     *         to formal types through a method invocation conversion).
     */

# Copy from Pydantic v2, compatible with v1
if sys.version_info < (3, 10):
    WithArgsTypes: tuple[Any, ...] = (typing._GenericAlias, types.GenericAlias)  # type: ignore[attr-defined]
else:
    WithArgsTypes: tuple[Any, ...] = (
        typing._GenericAlias,  # type: ignore[attr-defined]
        types.GenericAlias,
        types.UnionType,
    )  # pyright: ignore[reportAttributeAccessIssue]

    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public Collection<Type> provides() {
        return (Collection) types();
    }

    public Collection<DefaultType> types() {
        return Arrays.asList(
                // Maven types
                new DefaultType(Type.POM, Language.NONE, "pom", null, false),
                new DefaultType(Type.BOM, Language.NONE, "pom", null, false),

     *            The type of the Bean
     * @return The constructor
     */
    <T> Constructor<T> getConstructor();

    /**
     * Returns an array of the parameter types of the constructor.
     *
     * @return An array of the parameter types of the constructor
     */
    Class<?>[] getParameterTypes();

    /**
     * Returns {@literal true} if the constructor is {@literal public}.
     *

  dependencies:
    "@types/node" "*"

"@types/eslint-scope@^3.7.3":
  version "3.7.4"
  resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.4.tgz#37fc1223f0786c39627068a12e94d6e6fc61de16"
  integrity sha512-9K4zoImiZc3HlIp6AVUDE4CWYx22a+lhSZMYNpbjW04+YF0KWj4pJXnEMjdnFTiQibFFmElcsasJXDbdI/EPhA==
  dependencies:
    "@types/eslint" "*"
    "@types/estree" "*"

"@types/eslint@*":

     */
    private final Class<?> targetClass;

    /**
     * The parameter types.
     */
    private final Class<?>[] argTypes;

    /**
     * Creates a {@link NoSuchConstructorRuntimeException}.
     *
     * @param targetClass
     *            Target class
     * @param argTypes
     *            Array of parameter types
     * @param cause
     *            The cause of the exception
     */

Given these constraints, we cannot always follow best practices.  This ADR proposes the way we should handle the use of Provider APIs in the gradle/gradle codebase.

## Decision

### Types of properties that should not use lazy types

func (sys *HTTPConsoleLoggerSys) String() string {
	return logger.ConsoleLoggerTgt
}

// Stats returns the target statistics.
func (sys *HTTPConsoleLoggerSys) Stats() types.TargetStats {
	return types.TargetStats{
		TotalMessages:  atomic.LoadInt64(&sys.totalMessages),
		FailedMessages: atomic.LoadInt64(&sys.failedMessages),
		QueueLength:    0,
	}
}

// Content returns the console stdout log