private static Object unpack(ProviderResolutionStrategy providerResolutionStrategy, @Nullable Object deferred) {
        if (deferred == null) {
            return null;
        }
        Object value = unpackNestableDeferred(deferred);
        if (value instanceof Provider) {
            return providerResolutionStrategy.resolve((Provider<?>) value);
        }
        if (value instanceof Factory) {

    }

    @Override
    public void validate(PropertyValidationContext context) {
        // unnest callables without resolving deferred values (providers, factories)
        Object unnested = DeferredUtil.unpackNestableDeferred(value.call());
        if (isPresent(unnested)) {
            // only resolve deferred values if actually required by some action

    writeCollection(inputProperties) { property ->
        property.run {
            when (this) {
                is RegisteredProperty.InputFile -> {
                    val finalValue = DeferredUtil.unpackNestableDeferred(propertyValue)
                    writeInputProperty(propertyName, finalValue)
                    writeBoolean(optional)
                    writeBoolean(true)
                    writeEnum(filePropertyType)

            visitor.accept((FileCollectionInternal) ((TaskOutputs) element).getFiles());
        } else if (DeferredUtil.isNestableDeferred(element)) {
            Object deferredResult = DeferredUtil.unpackNestableDeferred(element);
            if (deferredResult != null) {
                add(deferredResult);
            }
        } else if (element instanceof Path) {

        boolean locationOnly,
        Consumer<OutputFilePropertySpec> consumer
    ) {
        Object unpackedValue = value.call();
        unpackedValue = DeferredUtil.unpackNestableDeferred(unpackedValue);
        if (locationOnly && unpackedValue instanceof FileSystemLocationProperty) {
            unpackedValue = ((FileSystemLocationProperty<?>) unpackedValue).getLocationOnly();
        }