b.Name = &value
	return b
}

// WithSource sets the Source field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Source field is set to the value of the last call.
func (b *PodResourceClaimApplyConfiguration) WithSource(value *ClaimSourceApplyConfiguration) *PodResourceClaimApplyConfiguration {

public interface ModuleSources {
    <T extends ModuleSource> Optional<T> getSource(Class<T> sourceType);

    void withSources(Consumer<ModuleSource> consumer);

    /**
     * Executes an action on the first source found of the following type, if any.
     */
    default <T extends ModuleSource, R> R withSource(Class<T> sourceType, Function<Optional<T>, R> action) {
        return action.apply(getSource(sourceType));
    }

    }

    private static Transformer<Object, ModuleComponentResolveMetadata> getKeyToSnapshotableTransformer() {
        return moduleMetadata -> moduleMetadata.getSources().withSource(ModuleDescriptorHashModuleSource.class, source -> {
            return source.map(metadataFileSource -> metadataFileSource.getDescriptorHash().toString() + moduleMetadata.getVariantDerivationStrategy().getClass().getName())

	panic("unimplemented")
}

func (f *recorderResourceManager) ServeHTTP(http.ResponseWriter, *http.Request) {
	panic("unimplemented")
}

func (f *recorderResourceManager) WithSource(source Source) ResourceManager {
	panic("unimplemented")

	return &ProjectedVolumeSourceApplyConfiguration{}
}

// WithSources adds the given value to the Sources field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.
// If called multiple times, values provided by each call will be appended to the Sources field.

        if (sources instanceof ImmutableModuleSources) {
            return new ImmutableModuleSources((ImmutableModuleSources) sources, source);
        }
        List<ModuleSource> all = new ArrayList<>();
        sources.withSources(all::add);
        all.add(source);
        return of(all.toArray(new ModuleSource[0]));
    }

    public static ImmutableModuleSources of(ModuleSources sources) {

                }
            }

            java {
                sourceSets {
                    withSources
                }
                registerFeature("withSources") {
                    usingSourceSet(sourceSets.withSources)
                    withSourcesJar()
                }
            }

            java {
                sourceSets {

     */
    MutableModuleComponentResolveMetadata asMutable();

    /**
     * Creates a copy of this meta-data with the given sources.
     */
    ModuleComponentResolveMetadata withSources(ModuleSources sources);

    /**

        }
        MutableModuleSources mutableModuleSources = new MutableModuleSources();
        if (sources == null) {
            return mutableModuleSources;
        }
        sources.withSources(mutableModuleSources::add);
        return mutableModuleSources;
    }

    @Override
    public <T extends ModuleSource> Optional<T> getSource(Class<T> sourceType) {
        if (moduleSources == null) {

        this.moduleSourceCodecs = moduleSourceCodecs;
    }

    @Override
    public void write(Encoder encoder, ModuleSources value) throws IOException {
        value.withSources(source -> {
            try {
                if (source instanceof PersistentModuleSource) {
                    PersistentModuleSource persistentModuleSource = (PersistentModuleSource) source;