extension.getCssFiles().from(css);

        extension.getRenderedDocumentation().from(stageDocs);

        Configuration runtimeClasspath = project.getConfigurations().getByName("runtimeClasspath");
        Configuration sourcesPath = project.getConfigurations().create("sourcesPath");
        sourcesPath.attributes(a -> {
            a.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.JAVA_RUNTIME));

        return getConfigurations(ideaModule, scope, SCOPE_PLUS);
    }

    private Collection<Configuration> getMinusConfigurations(IdeaModule ideaModule, GeneratedIdeaScope scope) {
        return getConfigurations(ideaModule, scope, SCOPE_MINUS);
    }

    private Collection<Configuration> getConfigurations(IdeaModule ideaModule, GeneratedIdeaScope scope, String plusMinus) {

     *
     * @return The set of configurations that apply, or an empty set if this exclude applies to _all_ configurations.
     */
    Set<String> getConfigurations();

        }
        ImmutableList.Builder<ExcludeMetadata> rules = ImmutableList.builderWithExpectedSize(excludes.size());
        for (Exclude exclude : excludes) {
            Set<String> ruleConfigurations = exclude.getConfigurations();
            if (include(ruleConfigurations, configurations)) {
                rules.add(exclude);
            }
        }
        return rules.build();
    }

                        });
                    }

                    private Configuration createBaseConfiguration(Project project) {
                        return project.getConfigurations().create("$TRANSFORM_SOURCE_CONFIGURATION", cfg -> {
                            cfg.setCanBeConsumed(false);
                            cfg.setCanBeResolved(true);
                        });
                    }

        AttributesSchemaInternal schema = (AttributesSchemaInternal) project.getDependencies().getAttributesSchema();
        ConfigurationsProvider configurations = (DefaultConfigurationContainer) project.getConfigurations();

        return resolveStateFactory.stateFor(projectState, componentIdentifier, moduleVersionIdentifier, configurations, module.getStatus(), schema);
    }

            task.dependsOn((Callable<FileCollection>) () -> mainFeature.getSourceSet().getRuntimeClasspath());
            task.classpath((Callable<FileCollection>) () -> {
                Configuration providedRuntime = project.getConfigurations().getByName(PROVIDED_RUNTIME_CONFIGURATION_NAME);
                return mainFeature.getSourceSet().getRuntimeClasspath().minus(providedRuntime);
            });
        });

        Attribute<Boolean> javaModule = Attribute.of("javaModule", Boolean.class);

        // compile and runtime classpath express that they only accept modules by requesting the javaModule=true attribute
        project.getConfigurations().matching(this::isResolvingJavaPluginConfiguration).all(
                c -> c.getAttributes().attribute(javaModule, true));

     */
    @Override
    RoleBasedConfigurationContainerInternal getConfigurations();

    interface DetachedResolver {
        RepositoryHandler getRepositories();

        DependencyHandler getDependencies();

        ConfigurationContainer getConfigurations();
    }

            this.file = file
            this.rawUuid = rawUuid
        }

        String getUuid() {
            return '{' + rawUuid + '}'
        }

        Map<String, String> getConfigurations() {
            def configurations = [:]
            content.eachMatch(~/\{${rawUuid}\}\.([\w\\-]+)\|\w+\.ActiveCfg = ([\w\\-]+)\|\w+/, {
                configurations[it[1]] = it[2]
            })